From 394f0deb1b1275cc289b349b6108f4a45593b14f Mon Sep 17 00:00:00 2001
From: Sy <mody.sy@eurecom.fr>
Date: Fri, 19 Jun 2020 23:38:37 +0200
Subject: [PATCH] bnProcPc and bnProc unrolled | BN treatment,  small
 improvement in times at the expense of degraded performance in BLER ,
 reordering of generated files

---
 cmake_targets/CMakeLists.txt                  |    2 +-
 ...176_rate_1-3_block_length_3848_maxit_5.txt |    0
 ...320_rate_1-3_block_length_7000_maxit_5.txt |    0
 ...384_rate_1-3_block_length_8000_maxit_5.txt |    0
 ...384_rate_1-3_block_length_8400_maxit_5.txt |    0
 ...84_rate_1-3_block_length_8448_maxit_10.txt |    0
 ...384_rate_1-3_block_length_8448_maxit_5.txt |  121 +-
 ...384_rate_2-3_block_length_8448_maxit_5.txt |   72 -
 ...2_rate_1-3_block_length_-27056_maxit_5.txt |    0
 ...320_rate_1-3_block_length_3200_maxit_5.txt |    0
 ...384_rate_1-3_block_length_3840_maxit_5.txt |    0
 ..._Zc_3_rate_1-3_block_length_16_maxit_5.txt |  152 --
 .../PHY/CODING/nrLDPC_decoder/nrLDPC_cnProc.h |  872 ++++++-
 .../CODING/nrLDPC_decoder/nrLDPC_decoder.c    | 2024 ++++++++++-------
 .../nrLDPC_decoder/nrLDPC_decoder.c.full      |  534 +++++
 .../PHY/CODING/nrLDPC_decoder/nrLDPC_mPass.h  |   29 +-
 .../generator_avx2/cnProc_gen_avx2            |  Bin 201040 -> 0 bytes
 .../nrLDPC_tools/generator_bnProc/Makefile    |   27 +
 .../generator_bnProc/bnProcPc_gen_BG1_avx2.c  | 1777 +++++++++++++++
 .../generator_bnProc/bnProcPc_gen_BG2_avx2.c  | 1773 +++++++++++++++
 .../generator_bnProc/bnProc_gen_BG1_avx2.c    | 1235 ++++++++++
 .../generator_bnProc/bnProc_gen_BG1_avx2.c.1  | 1235 ++++++++++
 .../generator_bnProc/bnProc_gen_BG2_avx2.c    | 1232 ++++++++++
 .../generator_bnProc/bnProc_gen_avx2          |  Bin 0 -> 617896 bytes
 .../nrLDPC_tools/generator_bnProc/main.c      |   28 +
 .../generator_bnProc/sauvegarde.tar.gz        |  Bin 0 -> 9050 bytes
 .../Makefile                                  |    0
 .../cnProc_gen_BG1_avx2.c                     |    6 +-
 .../cnProc_gen_BG2_avx2.c                     |    4 +-
 .../generator_cnProc/cnProc_gen_avx2          |  Bin 0 -> 43488 bytes
 .../main.c                                    |    8 +-
 .../Makefile                                  |    0
 .../cnProc_gen_BG1_avx512.2                   |  583 +++++
 .../cnProc_gen_BG1_avx512.c                   |    5 +-
 .../cnProc_gen_BG2_avx512.c                   |    4 +-
 .../cnProc_gen_avx512                         |  Bin 43360 -> 43368 bytes
 .../main.c                                    |    0
 .../generator_cnProc_avx512/sauvegarde.tar.gz |  Bin 0 -> 3870 bytes
 .../bnProc/nrLDPC_bnProc_BG1_Z104_R13_AVX2.c  |  978 ++++++++
 .../bnProc/nrLDPC_bnProc_BG1_Z10_R13_AVX2.c   |  978 ++++++++
 .../bnProc/nrLDPC_bnProc_BG1_Z112_R13_AVX2.c  |  978 ++++++++
 .../bnProc/nrLDPC_bnProc_BG1_Z11_R13_AVX2.c   |  978 ++++++++
 .../bnProc/nrLDPC_bnProc_BG1_Z120_R13_AVX2.c  |  978 ++++++++
 .../bnProc/nrLDPC_bnProc_BG1_Z128_R13_AVX2.c  |  978 ++++++++
 .../bnProc/nrLDPC_bnProc_BG1_Z12_R13_AVX2.c   |  978 ++++++++
 .../bnProc/nrLDPC_bnProc_BG1_Z13_R13_AVX2.c   |  978 ++++++++
 .../bnProc/nrLDPC_bnProc_BG1_Z144_R13_AVX2.c  |  978 ++++++++
 .../bnProc/nrLDPC_bnProc_BG1_Z14_R13_AVX2.c   |  978 ++++++++
 .../bnProc/nrLDPC_bnProc_BG1_Z15_R13_AVX2.c   |  978 ++++++++
 .../bnProc/nrLDPC_bnProc_BG1_Z160_R13_AVX2.c  |  978 ++++++++
 .../bnProc/nrLDPC_bnProc_BG1_Z16_R13_AVX2.c   |  978 ++++++++
 .../bnProc/nrLDPC_bnProc_BG1_Z176_R13_AVX2.c  |  978 ++++++++
 .../bnProc/nrLDPC_bnProc_BG1_Z18_R13_AVX2.c   |  978 ++++++++
 .../bnProc/nrLDPC_bnProc_BG1_Z192_R13_AVX2.c  |  978 ++++++++
 .../bnProc/nrLDPC_bnProc_BG1_Z208_R13_AVX2.c  |  978 ++++++++
 .../bnProc/nrLDPC_bnProc_BG1_Z20_R13_AVX2.c   |  978 ++++++++
 .../bnProc/nrLDPC_bnProc_BG1_Z224_R13_AVX2.c  |  978 ++++++++
 .../bnProc/nrLDPC_bnProc_BG1_Z22_R13_AVX2.c   |  978 ++++++++
 .../bnProc/nrLDPC_bnProc_BG1_Z240_R13_AVX2.c  |  978 ++++++++
 .../bnProc/nrLDPC_bnProc_BG1_Z24_R13_AVX2.c   |  978 ++++++++
 .../bnProc/nrLDPC_bnProc_BG1_Z256_R13_AVX2.c  |  978 ++++++++
 .../bnProc/nrLDPC_bnProc_BG1_Z26_R13_AVX2.c   |  978 ++++++++
 .../bnProc/nrLDPC_bnProc_BG1_Z288_R13_AVX2.c  |  978 ++++++++
 .../bnProc/nrLDPC_bnProc_BG1_Z28_R13_AVX2.c   |  978 ++++++++
 .../bnProc/nrLDPC_bnProc_BG1_Z2_R13_AVX2.c    |  978 ++++++++
 .../bnProc/nrLDPC_bnProc_BG1_Z30_R13_AVX2.c   |  978 ++++++++
 .../bnProc/nrLDPC_bnProc_BG1_Z320_R13_AVX2.c  |  978 ++++++++
 .../bnProc/nrLDPC_bnProc_BG1_Z32_R13_AVX2.c   |  978 ++++++++
 .../bnProc/nrLDPC_bnProc_BG1_Z352_R13_AVX2.c  |  978 ++++++++
 .../bnProc/nrLDPC_bnProc_BG1_Z36_R13_AVX2.c   |  978 ++++++++
 .../bnProc/nrLDPC_bnProc_BG1_Z384_R13_AVX2.c  |  978 ++++++++
 .../bnProc/nrLDPC_bnProc_BG1_Z3_R13_AVX2.c    |  978 ++++++++
 .../bnProc/nrLDPC_bnProc_BG1_Z40_R13_AVX2.c   |  978 ++++++++
 .../bnProc/nrLDPC_bnProc_BG1_Z44_R13_AVX2.c   |  978 ++++++++
 .../bnProc/nrLDPC_bnProc_BG1_Z48_R13_AVX2.c   |  978 ++++++++
 .../bnProc/nrLDPC_bnProc_BG1_Z4_R13_AVX2.c    |  978 ++++++++
 .../bnProc/nrLDPC_bnProc_BG1_Z52_R13_AVX2.c   |  978 ++++++++
 .../bnProc/nrLDPC_bnProc_BG1_Z56_R13_AVX2.c   |  978 ++++++++
 .../bnProc/nrLDPC_bnProc_BG1_Z5_R13_AVX2.c    |  978 ++++++++
 .../bnProc/nrLDPC_bnProc_BG1_Z60_R13_AVX2.c   |  978 ++++++++
 .../bnProc/nrLDPC_bnProc_BG1_Z64_R13_AVX2.c   |  978 ++++++++
 .../bnProc/nrLDPC_bnProc_BG1_Z6_R13_AVX2.c    |  978 ++++++++
 .../bnProc/nrLDPC_bnProc_BG1_Z72_R13_AVX2.c   |  978 ++++++++
 .../bnProc/nrLDPC_bnProc_BG1_Z7_R13_AVX2.c    |  978 ++++++++
 .../bnProc/nrLDPC_bnProc_BG1_Z80_R13_AVX2.c   |  978 ++++++++
 .../bnProc/nrLDPC_bnProc_BG1_Z88_R13_AVX2.c   |  978 ++++++++
 .../bnProc/nrLDPC_bnProc_BG1_Z8_R13_AVX2.c    |  978 ++++++++
 .../bnProc/nrLDPC_bnProc_BG1_Z96_R13_AVX2.c   |  978 ++++++++
 .../bnProc/nrLDPC_bnProc_BG1_Z9_R13_AVX2.c    |  978 ++++++++
 .../bnProc/nrLDPC_bnProc_BG2_Z104_R15_AVX2.c  |  992 ++++++++
 .../bnProc/nrLDPC_bnProc_BG2_Z10_R15_AVX2.c   |  992 ++++++++
 .../bnProc/nrLDPC_bnProc_BG2_Z112_R15_AVX2.c  |  992 ++++++++
 .../bnProc/nrLDPC_bnProc_BG2_Z11_R15_AVX2.c   |  992 ++++++++
 .../bnProc/nrLDPC_bnProc_BG2_Z120_R15_AVX2.c  |  992 ++++++++
 .../bnProc/nrLDPC_bnProc_BG2_Z128_R15_AVX2.c  |  992 ++++++++
 .../bnProc/nrLDPC_bnProc_BG2_Z12_R15_AVX2.c   |  992 ++++++++
 .../bnProc/nrLDPC_bnProc_BG2_Z13_R15_AVX2.c   |  992 ++++++++
 .../bnProc/nrLDPC_bnProc_BG2_Z144_R15_AVX2.c  |  992 ++++++++
 .../bnProc/nrLDPC_bnProc_BG2_Z14_R15_AVX2.c   |  992 ++++++++
 .../bnProc/nrLDPC_bnProc_BG2_Z15_R15_AVX2.c   |  992 ++++++++
 .../bnProc/nrLDPC_bnProc_BG2_Z160_R15_AVX2.c  |  992 ++++++++
 .../bnProc/nrLDPC_bnProc_BG2_Z16_R15_AVX2.c   |  992 ++++++++
 .../bnProc/nrLDPC_bnProc_BG2_Z176_R15_AVX2.c  |  992 ++++++++
 .../bnProc/nrLDPC_bnProc_BG2_Z18_R15_AVX2.c   |  992 ++++++++
 .../bnProc/nrLDPC_bnProc_BG2_Z192_R15_AVX2.c  |  992 ++++++++
 .../bnProc/nrLDPC_bnProc_BG2_Z208_R15_AVX2.c  |  992 ++++++++
 .../bnProc/nrLDPC_bnProc_BG2_Z20_R15_AVX2.c   |  992 ++++++++
 .../bnProc/nrLDPC_bnProc_BG2_Z224_R15_AVX2.c  |  992 ++++++++
 .../bnProc/nrLDPC_bnProc_BG2_Z22_R15_AVX2.c   |  992 ++++++++
 .../bnProc/nrLDPC_bnProc_BG2_Z240_R15_AVX2.c  |  992 ++++++++
 .../bnProc/nrLDPC_bnProc_BG2_Z24_R15_AVX2.c   |  992 ++++++++
 .../bnProc/nrLDPC_bnProc_BG2_Z256_R15_AVX2.c  |  992 ++++++++
 .../bnProc/nrLDPC_bnProc_BG2_Z26_R15_AVX2.c   |  992 ++++++++
 .../bnProc/nrLDPC_bnProc_BG2_Z288_R15_AVX2.c  |  992 ++++++++
 .../bnProc/nrLDPC_bnProc_BG2_Z28_R15_AVX2.c   |  992 ++++++++
 .../bnProc/nrLDPC_bnProc_BG2_Z2_R15_AVX2.c    |  992 ++++++++
 .../bnProc/nrLDPC_bnProc_BG2_Z30_R15_AVX2.c   |  992 ++++++++
 .../bnProc/nrLDPC_bnProc_BG2_Z320_R15_AVX2.c  |  992 ++++++++
 .../bnProc/nrLDPC_bnProc_BG2_Z32_R15_AVX2.c   |  992 ++++++++
 .../bnProc/nrLDPC_bnProc_BG2_Z352_R15_AVX2.c  |  992 ++++++++
 .../bnProc/nrLDPC_bnProc_BG2_Z36_R15_AVX2.c   |  992 ++++++++
 .../bnProc/nrLDPC_bnProc_BG2_Z384_R15_AVX2.c  |  992 ++++++++
 .../bnProc/nrLDPC_bnProc_BG2_Z3_R15_AVX2.c    |  992 ++++++++
 .../bnProc/nrLDPC_bnProc_BG2_Z40_R15_AVX2.c   |  992 ++++++++
 .../bnProc/nrLDPC_bnProc_BG2_Z44_R15_AVX2.c   |  992 ++++++++
 .../bnProc/nrLDPC_bnProc_BG2_Z48_R15_AVX2.c   |  992 ++++++++
 .../bnProc/nrLDPC_bnProc_BG2_Z4_R15_AVX2.c    |  992 ++++++++
 .../bnProc/nrLDPC_bnProc_BG2_Z52_R15_AVX2.c   |  992 ++++++++
 .../bnProc/nrLDPC_bnProc_BG2_Z56_R15_AVX2.c   |  992 ++++++++
 .../bnProc/nrLDPC_bnProc_BG2_Z5_R15_AVX2.c    |  992 ++++++++
 .../bnProc/nrLDPC_bnProc_BG2_Z60_R15_AVX2.c   |  992 ++++++++
 .../bnProc/nrLDPC_bnProc_BG2_Z64_R15_AVX2.c   |  992 ++++++++
 .../bnProc/nrLDPC_bnProc_BG2_Z6_R15_AVX2.c    |  992 ++++++++
 .../bnProc/nrLDPC_bnProc_BG2_Z72_R15_AVX2.c   |  992 ++++++++
 .../bnProc/nrLDPC_bnProc_BG2_Z7_R15_AVX2.c    |  992 ++++++++
 .../bnProc/nrLDPC_bnProc_BG2_Z80_R15_AVX2.c   |  992 ++++++++
 .../bnProc/nrLDPC_bnProc_BG2_Z88_R15_AVX2.c   |  992 ++++++++
 .../bnProc/nrLDPC_bnProc_BG2_Z8_R15_AVX2.c    |  992 ++++++++
 .../bnProc/nrLDPC_bnProc_BG2_Z96_R15_AVX2.c   |  992 ++++++++
 .../bnProc/nrLDPC_bnProc_BG2_Z9_R15_AVX2.c    |  992 ++++++++
 .../nrLDPC_bnProcPc_BG1_Z104_R13_AVX2.c       |  749 ++++++
 .../nrLDPC_bnProcPc_BG1_Z10_R13_AVX2.c        |  749 ++++++
 .../nrLDPC_bnProcPc_BG1_Z112_R13_AVX2.c       |  749 ++++++
 .../nrLDPC_bnProcPc_BG1_Z11_R13_AVX2.c        |  749 ++++++
 .../nrLDPC_bnProcPc_BG1_Z120_R13_AVX2.c       |  749 ++++++
 .../nrLDPC_bnProcPc_BG1_Z128_R13_AVX2.c       |  749 ++++++
 .../nrLDPC_bnProcPc_BG1_Z12_R13_AVX2.c        |  749 ++++++
 .../nrLDPC_bnProcPc_BG1_Z13_R13_AVX2.c        |  749 ++++++
 .../nrLDPC_bnProcPc_BG1_Z144_R13_AVX2.c       |  749 ++++++
 .../nrLDPC_bnProcPc_BG1_Z14_R13_AVX2.c        |  749 ++++++
 .../nrLDPC_bnProcPc_BG1_Z15_R13_AVX2.c        |  749 ++++++
 .../nrLDPC_bnProcPc_BG1_Z160_R13_AVX2.c       |  749 ++++++
 .../nrLDPC_bnProcPc_BG1_Z16_R13_AVX2.c        |  749 ++++++
 .../nrLDPC_bnProcPc_BG1_Z176_R13_AVX2.c       |  749 ++++++
 .../nrLDPC_bnProcPc_BG1_Z18_R13_AVX2.c        |  749 ++++++
 .../nrLDPC_bnProcPc_BG1_Z192_R13_AVX2.c       |  749 ++++++
 .../nrLDPC_bnProcPc_BG1_Z208_R13_AVX2.c       |  749 ++++++
 .../nrLDPC_bnProcPc_BG1_Z20_R13_AVX2.c        |  749 ++++++
 .../nrLDPC_bnProcPc_BG1_Z224_R13_AVX2.c       |  749 ++++++
 .../nrLDPC_bnProcPc_BG1_Z22_R13_AVX2.c        |  749 ++++++
 .../nrLDPC_bnProcPc_BG1_Z240_R13_AVX2.c       |  749 ++++++
 .../nrLDPC_bnProcPc_BG1_Z24_R13_AVX2.c        |  749 ++++++
 .../nrLDPC_bnProcPc_BG1_Z256_R13_AVX2.c       |  749 ++++++
 .../nrLDPC_bnProcPc_BG1_Z26_R13_AVX2.c        |  749 ++++++
 .../nrLDPC_bnProcPc_BG1_Z288_R13_AVX2.c       |  749 ++++++
 .../nrLDPC_bnProcPc_BG1_Z28_R13_AVX2.c        |  749 ++++++
 .../nrLDPC_bnProcPc_BG1_Z2_R13_AVX2.c         |  749 ++++++
 .../nrLDPC_bnProcPc_BG1_Z30_R13_AVX2.c        |  749 ++++++
 .../nrLDPC_bnProcPc_BG1_Z320_R13_AVX2.c       |  749 ++++++
 .../nrLDPC_bnProcPc_BG1_Z32_R13_AVX2.c        |  749 ++++++
 .../nrLDPC_bnProcPc_BG1_Z352_R13_AVX2.c       |  749 ++++++
 .../nrLDPC_bnProcPc_BG1_Z36_R13_AVX2.c        |  749 ++++++
 .../nrLDPC_bnProcPc_BG1_Z384_R13_AVX2.c       |  749 ++++++
 .../nrLDPC_bnProcPc_BG1_Z3_R13_AVX2.c         |  749 ++++++
 .../nrLDPC_bnProcPc_BG1_Z40_R13_AVX2.c        |  749 ++++++
 .../nrLDPC_bnProcPc_BG1_Z44_R13_AVX2.c        |  749 ++++++
 .../nrLDPC_bnProcPc_BG1_Z48_R13_AVX2.c        |  749 ++++++
 .../nrLDPC_bnProcPc_BG1_Z4_R13_AVX2.c         |  749 ++++++
 .../nrLDPC_bnProcPc_BG1_Z52_R13_AVX2.c        |  749 ++++++
 .../nrLDPC_bnProcPc_BG1_Z56_R13_AVX2.c        |  749 ++++++
 .../nrLDPC_bnProcPc_BG1_Z5_R13_AVX2.c         |  749 ++++++
 .../nrLDPC_bnProcPc_BG1_Z60_R13_AVX2.c        |  749 ++++++
 .../nrLDPC_bnProcPc_BG1_Z64_R13_AVX2.c        |  749 ++++++
 .../nrLDPC_bnProcPc_BG1_Z6_R13_AVX2.c         |  749 ++++++
 .../nrLDPC_bnProcPc_BG1_Z72_R13_AVX2.c        |  749 ++++++
 .../nrLDPC_bnProcPc_BG1_Z7_R13_AVX2.c         |  749 ++++++
 .../nrLDPC_bnProcPc_BG1_Z80_R13_AVX2.c        |  749 ++++++
 .../nrLDPC_bnProcPc_BG1_Z88_R13_AVX2.c        |  749 ++++++
 .../nrLDPC_bnProcPc_BG1_Z8_R13_AVX2.c         |  749 ++++++
 .../nrLDPC_bnProcPc_BG1_Z96_R13_AVX2.c        |  749 ++++++
 .../nrLDPC_bnProcPc_BG1_Z9_R13_AVX2.c         |  749 ++++++
 .../nrLDPC_bnProcPc_BG2_Z104_R15_AVX2.c       |  757 ++++++
 .../nrLDPC_bnProcPc_BG2_Z10_R15_AVX2.c        |  757 ++++++
 .../nrLDPC_bnProcPc_BG2_Z112_R15_AVX2.c       |  757 ++++++
 .../nrLDPC_bnProcPc_BG2_Z11_R15_AVX2.c        |  757 ++++++
 .../nrLDPC_bnProcPc_BG2_Z120_R15_AVX2.c       |  757 ++++++
 .../nrLDPC_bnProcPc_BG2_Z128_R15_AVX2.c       |  757 ++++++
 .../nrLDPC_bnProcPc_BG2_Z12_R15_AVX2.c        |  757 ++++++
 .../nrLDPC_bnProcPc_BG2_Z13_R15_AVX2.c        |  757 ++++++
 .../nrLDPC_bnProcPc_BG2_Z144_R15_AVX2.c       |  757 ++++++
 .../nrLDPC_bnProcPc_BG2_Z14_R15_AVX2.c        |  757 ++++++
 .../nrLDPC_bnProcPc_BG2_Z15_R15_AVX2.c        |  757 ++++++
 .../nrLDPC_bnProcPc_BG2_Z160_R15_AVX2.c       |  757 ++++++
 .../nrLDPC_bnProcPc_BG2_Z16_R15_AVX2.c        |  757 ++++++
 .../nrLDPC_bnProcPc_BG2_Z176_R15_AVX2.c       |  757 ++++++
 .../nrLDPC_bnProcPc_BG2_Z18_R15_AVX2.c        |  757 ++++++
 .../nrLDPC_bnProcPc_BG2_Z192_R15_AVX2.c       |  757 ++++++
 .../nrLDPC_bnProcPc_BG2_Z208_R15_AVX2.c       |  757 ++++++
 .../nrLDPC_bnProcPc_BG2_Z20_R15_AVX2.c        |  757 ++++++
 .../nrLDPC_bnProcPc_BG2_Z224_R15_AVX2.c       |  757 ++++++
 .../nrLDPC_bnProcPc_BG2_Z22_R15_AVX2.c        |  757 ++++++
 .../nrLDPC_bnProcPc_BG2_Z240_R15_AVX2.c       |  757 ++++++
 .../nrLDPC_bnProcPc_BG2_Z24_R15_AVX2.c        |  757 ++++++
 .../nrLDPC_bnProcPc_BG2_Z256_R15_AVX2.c       |  757 ++++++
 .../nrLDPC_bnProcPc_BG2_Z26_R15_AVX2.c        |  757 ++++++
 .../nrLDPC_bnProcPc_BG2_Z288_R15_AVX2.c       |  757 ++++++
 .../nrLDPC_bnProcPc_BG2_Z28_R15_AVX2.c        |  757 ++++++
 .../nrLDPC_bnProcPc_BG2_Z2_R15_AVX2.c         |  757 ++++++
 .../nrLDPC_bnProcPc_BG2_Z30_R15_AVX2.c        |  757 ++++++
 .../nrLDPC_bnProcPc_BG2_Z320_R15_AVX2.c       |  757 ++++++
 .../nrLDPC_bnProcPc_BG2_Z32_R15_AVX2.c        |  757 ++++++
 .../nrLDPC_bnProcPc_BG2_Z352_R15_AVX2.c       |  757 ++++++
 .../nrLDPC_bnProcPc_BG2_Z36_R15_AVX2.c        |  757 ++++++
 .../nrLDPC_bnProcPc_BG2_Z384_R15_AVX2.c       |  757 ++++++
 .../nrLDPC_bnProcPc_BG2_Z3_R15_AVX2.c         |  757 ++++++
 .../nrLDPC_bnProcPc_BG2_Z40_R15_AVX2.c        |  757 ++++++
 .../nrLDPC_bnProcPc_BG2_Z44_R15_AVX2.c        |  757 ++++++
 .../nrLDPC_bnProcPc_BG2_Z48_R15_AVX2.c        |  757 ++++++
 .../nrLDPC_bnProcPc_BG2_Z4_R15_AVX2.c         |  757 ++++++
 .../nrLDPC_bnProcPc_BG2_Z52_R15_AVX2.c        |  757 ++++++
 .../nrLDPC_bnProcPc_BG2_Z56_R15_AVX2.c        |  757 ++++++
 .../nrLDPC_bnProcPc_BG2_Z5_R15_AVX2.c         |  757 ++++++
 .../nrLDPC_bnProcPc_BG2_Z60_R15_AVX2.c        |  757 ++++++
 .../nrLDPC_bnProcPc_BG2_Z64_R15_AVX2.c        |  757 ++++++
 .../nrLDPC_bnProcPc_BG2_Z6_R15_AVX2.c         |  757 ++++++
 .../nrLDPC_bnProcPc_BG2_Z72_R15_AVX2.c        |  757 ++++++
 .../nrLDPC_bnProcPc_BG2_Z7_R15_AVX2.c         |  757 ++++++
 .../nrLDPC_bnProcPc_BG2_Z80_R15_AVX2.c        |  757 ++++++
 .../nrLDPC_bnProcPc_BG2_Z88_R15_AVX2.c        |  757 ++++++
 .../nrLDPC_bnProcPc_BG2_Z8_R15_AVX2.c         |  757 ++++++
 .../nrLDPC_bnProcPc_BG2_Z96_R15_AVX2.c        |  757 ++++++
 .../nrLDPC_bnProcPc_BG2_Z9_R15_AVX2.c         |  757 ++++++
 .../nrLDPC_cnProc_BG1_Z104_R13_AVX2.c}        |    2 +-
 .../nrLDPC_cnProc_BG1_Z10_R13_AVX2.c}         |    2 +-
 .../nrLDPC_cnProc_BG1_Z112_R13_AVX2.c}        |    2 +-
 .../nrLDPC_cnProc_BG1_Z11_R13_AVX2.c}         |    2 +-
 .../nrLDPC_cnProc_BG1_Z120_R13_AVX2.c}        |    2 +-
 .../nrLDPC_cnProc_BG1_Z128_R13_AVX2.c}        |    2 +-
 .../nrLDPC_cnProc_BG1_Z12_R13_AVX2.c}         |    2 +-
 .../nrLDPC_cnProc_BG1_Z13_R13_AVX2.c}         |    2 +-
 .../nrLDPC_cnProc_BG1_Z144_R13_AVX2.c}        |    2 +-
 .../nrLDPC_cnProc_BG1_Z14_R13_AVX2.c}         |    2 +-
 .../nrLDPC_cnProc_BG1_Z15_R13_AVX2.c}         |    2 +-
 .../nrLDPC_cnProc_BG1_Z160_R13_AVX2.c}        |    2 +-
 .../nrLDPC_cnProc_BG1_Z16_R13_AVX2.c}         |    2 +-
 .../nrLDPC_cnProc_BG1_Z176_R13_AVX2.c}        |    2 +-
 .../nrLDPC_cnProc_BG1_Z18_R13_AVX2.c}         |    2 +-
 .../nrLDPC_cnProc_BG1_Z192_R13_AVX2.c}        |    2 +-
 .../nrLDPC_cnProc_BG1_Z208_R13_AVX2.c}        |    2 +-
 .../nrLDPC_cnProc_BG1_Z20_R13_AVX2.c}         |    2 +-
 .../nrLDPC_cnProc_BG1_Z224_R13_AVX2.c}        |    2 +-
 .../nrLDPC_cnProc_BG1_Z22_R13_AVX2.c}         |    2 +-
 .../nrLDPC_cnProc_BG1_Z240_R13_AVX2.c}        |    2 +-
 .../nrLDPC_cnProc_BG1_Z24_R13_AVX2.c}         |    2 +-
 .../nrLDPC_cnProc_BG1_Z256_R13_AVX2.c}        |    2 +-
 .../nrLDPC_cnProc_BG1_Z26_R13_AVX2.c}         |    2 +-
 .../nrLDPC_cnProc_BG1_Z288_R13_AVX2.c}        |    2 +-
 .../nrLDPC_cnProc_BG1_Z28_R13_AVX2.c}         |    2 +-
 .../nrLDPC_cnProc_BG1_Z2_R13_AVX2.c}          |    2 +-
 .../nrLDPC_cnProc_BG1_Z30_R13_AVX2.c}         |    2 +-
 .../nrLDPC_cnProc_BG1_Z320_R13_AVX2.c}        |    2 +-
 .../nrLDPC_cnProc_BG1_Z32_R13_AVX2.c}         |    2 +-
 .../nrLDPC_cnProc_BG1_Z352_R13_AVX2.c}        |    2 +-
 .../nrLDPC_cnProc_BG1_Z36_R13_AVX2.c}         |    2 +-
 .../nrLDPC_cnProc_BG1_Z384_R13_AVX2.c}        |    2 +-
 .../nrLDPC_cnProc_BG1_Z3_R13_AVX2.c}          |    2 +-
 .../nrLDPC_cnProc_BG1_Z40_R13_AVX2.c}         |    2 +-
 .../nrLDPC_cnProc_BG1_Z44_R13_AVX2.c}         |    2 +-
 .../nrLDPC_cnProc_BG1_Z48_R13_AVX2.c}         |    2 +-
 .../nrLDPC_cnProc_BG1_Z4_R13_AVX2.c}          |    2 +-
 .../nrLDPC_cnProc_BG1_Z52_R13_AVX2.c}         |    2 +-
 .../nrLDPC_cnProc_BG1_Z56_R13_AVX2.c}         |    2 +-
 .../nrLDPC_cnProc_BG1_Z5_R13_AVX2.c}          |    2 +-
 .../nrLDPC_cnProc_BG1_Z60_R13_AVX2.c}         |    2 +-
 .../nrLDPC_cnProc_BG1_Z64_R13_AVX2.c}         |    2 +-
 .../nrLDPC_cnProc_BG1_Z6_R13_AVX2.c}          |    2 +-
 .../nrLDPC_cnProc_BG1_Z72_R13_AVX2.c}         |    2 +-
 .../nrLDPC_cnProc_BG1_Z7_R13_AVX2.c}          |    2 +-
 .../nrLDPC_cnProc_BG1_Z80_R13_AVX2.c}         |    2 +-
 .../nrLDPC_cnProc_BG1_Z88_R13_AVX2.c}         |    2 +-
 .../nrLDPC_cnProc_BG1_Z8_R13_AVX2.c}          |    2 +-
 .../nrLDPC_cnProc_BG1_Z96_R13_AVX2.c}         |    2 +-
 .../nrLDPC_cnProc_BG1_Z9_R13_AVX2.c}          |    2 +-
 .../nrLDPC_cnProc_BG2_Z104_R15_AVX2.c}        |    2 +-
 .../nrLDPC_cnProc_BG2_Z10_R15_AVX2.c}         |    2 +-
 .../nrLDPC_cnProc_BG2_Z112_R15_AVX2.c}        |    2 +-
 .../nrLDPC_cnProc_BG2_Z11_R15_AVX2.c}         |    2 +-
 .../nrLDPC_cnProc_BG2_Z120_R15_AVX2.c}        |    2 +-
 .../nrLDPC_cnProc_BG2_Z128_R15_AVX2.c}        |    2 +-
 .../nrLDPC_cnProc_BG2_Z12_R15_AVX2.c}         |    2 +-
 .../nrLDPC_cnProc_BG2_Z13_R15_AVX2.c}         |    2 +-
 .../nrLDPC_cnProc_BG2_Z144_R15_AVX2.c}        |    2 +-
 .../nrLDPC_cnProc_BG2_Z14_R15_AVX2.c}         |    2 +-
 .../nrLDPC_cnProc_BG2_Z15_R15_AVX2.c}         |    2 +-
 .../nrLDPC_cnProc_BG2_Z160_R15_AVX2.c}        |    2 +-
 .../nrLDPC_cnProc_BG2_Z16_R15_AVX2.c}         |    2 +-
 .../nrLDPC_cnProc_BG2_Z176_R15_AVX2.c}        |    2 +-
 .../nrLDPC_cnProc_BG2_Z18_R15_AVX2.c}         |    2 +-
 .../nrLDPC_cnProc_BG2_Z192_R15_AVX2.c}        |    2 +-
 .../nrLDPC_cnProc_BG2_Z208_R15_AVX2.c}        |    2 +-
 .../nrLDPC_cnProc_BG2_Z20_R15_AVX2.c}         |    2 +-
 .../nrLDPC_cnProc_BG2_Z224_R15_AVX2.c}        |    2 +-
 .../nrLDPC_cnProc_BG2_Z22_R15_AVX2.c}         |    2 +-
 .../nrLDPC_cnProc_BG2_Z240_R15_AVX2.c}        |    2 +-
 .../nrLDPC_cnProc_BG2_Z24_R15_AVX2.c}         |    2 +-
 .../nrLDPC_cnProc_BG2_Z256_R15_AVX2.c}        |    2 +-
 .../nrLDPC_cnProc_BG2_Z26_R15_AVX2.c}         |    2 +-
 .../nrLDPC_cnProc_BG2_Z288_R15_AVX2.c}        |    2 +-
 .../nrLDPC_cnProc_BG2_Z28_R15_AVX2.c}         |    2 +-
 .../nrLDPC_cnProc_BG2_Z2_R15_AVX2.c}          |    2 +-
 .../nrLDPC_cnProc_BG2_Z30_R15_AVX2.c}         |    2 +-
 .../nrLDPC_cnProc_BG2_Z320_R15_AVX2.c}        |    2 +-
 .../nrLDPC_cnProc_BG2_Z32_R15_AVX2.c}         |    2 +-
 .../nrLDPC_cnProc_BG2_Z352_R15_AVX2.c}        |    2 +-
 .../nrLDPC_cnProc_BG2_Z36_R15_AVX2.c}         |    2 +-
 .../nrLDPC_cnProc_BG2_Z384_R15_AVX2.c}        |    2 +-
 .../nrLDPC_cnProc_BG2_Z3_R15_AVX2.c}          |    2 +-
 .../nrLDPC_cnProc_BG2_Z40_R15_AVX2.c}         |    2 +-
 .../nrLDPC_cnProc_BG2_Z44_R15_AVX2.c}         |    2 +-
 .../nrLDPC_cnProc_BG2_Z48_R15_AVX2.c}         |    2 +-
 .../nrLDPC_cnProc_BG2_Z4_R15_AVX2.c}          |    2 +-
 .../nrLDPC_cnProc_BG2_Z52_R15_AVX2.c}         |    2 +-
 .../nrLDPC_cnProc_BG2_Z56_R15_AVX2.c}         |    2 +-
 .../nrLDPC_cnProc_BG2_Z5_R15_AVX2.c}          |    2 +-
 .../nrLDPC_cnProc_BG2_Z60_R15_AVX2.c}         |    2 +-
 .../nrLDPC_cnProc_BG2_Z64_R15_AVX2.c}         |    2 +-
 .../nrLDPC_cnProc_BG2_Z6_R15_AVX2.c}          |    2 +-
 .../nrLDPC_cnProc_BG2_Z72_R15_AVX2.c}         |    2 +-
 .../nrLDPC_cnProc_BG2_Z7_R15_AVX2.c}          |    2 +-
 .../nrLDPC_cnProc_BG2_Z80_R15_AVX2.c}         |    2 +-
 .../nrLDPC_cnProc_BG2_Z88_R15_AVX2.c}         |    2 +-
 .../nrLDPC_cnProc_BG2_Z8_R15_AVX2.c}          |    2 +-
 .../nrLDPC_cnProc_BG2_Z96_R15_AVX2.c}         |    2 +-
 .../nrLDPC_cnProc_BG2_Z9_R15_AVX2.c}          |    2 +-
 ....c => nrLDPC_cnProc_BG1_Z104_R13_AVX512.c} |    2 +-
 ...2.c => nrLDPC_cnProc_BG1_Z10_R13_AVX512.c} |    2 +-
 ....c => nrLDPC_cnProc_BG1_Z112_R13_AVX512.c} |    2 +-
 ...2.c => nrLDPC_cnProc_BG1_Z11_R13_AVX512.c} |    2 +-
 ....c => nrLDPC_cnProc_BG1_Z120_R13_AVX512.c} |    2 +-
 ....c => nrLDPC_cnProc_BG1_Z128_R13_AVX512.c} |    2 +-
 ...2.c => nrLDPC_cnProc_BG1_Z12_R13_AVX512.c} |    2 +-
 ...2.c => nrLDPC_cnProc_BG1_Z13_R13_AVX512.c} |    2 +-
 ....c => nrLDPC_cnProc_BG1_Z144_R13_AVX512.c} |    2 +-
 ...2.c => nrLDPC_cnProc_BG1_Z14_R13_AVX512.c} |    2 +-
 ...2.c => nrLDPC_cnProc_BG1_Z15_R13_AVX512.c} |    2 +-
 ....c => nrLDPC_cnProc_BG1_Z160_R13_AVX512.c} |    2 +-
 ...2.c => nrLDPC_cnProc_BG1_Z16_R13_AVX512.c} |    2 +-
 ....c => nrLDPC_cnProc_BG1_Z176_R13_AVX512.c} |    2 +-
 ...2.c => nrLDPC_cnProc_BG1_Z18_R13_AVX512.c} |    2 +-
 ....c => nrLDPC_cnProc_BG1_Z192_R13_AVX512.c} |    2 +-
 ....c => nrLDPC_cnProc_BG1_Z208_R13_AVX512.c} |    2 +-
 ...2.c => nrLDPC_cnProc_BG1_Z20_R13_AVX512.c} |    2 +-
 ....c => nrLDPC_cnProc_BG1_Z224_R13_AVX512.c} |    2 +-
 ...2.c => nrLDPC_cnProc_BG1_Z22_R13_AVX512.c} |    2 +-
 ....c => nrLDPC_cnProc_BG1_Z240_R13_AVX512.c} |    2 +-
 ...2.c => nrLDPC_cnProc_BG1_Z24_R13_AVX512.c} |    2 +-
 ....c => nrLDPC_cnProc_BG1_Z256_R13_AVX512.c} |    2 +-
 ...2.c => nrLDPC_cnProc_BG1_Z26_R13_AVX512.c} |    2 +-
 ....c => nrLDPC_cnProc_BG1_Z288_R13_AVX512.c} |    2 +-
 ...2.c => nrLDPC_cnProc_BG1_Z28_R13_AVX512.c} |    2 +-
 ...12.c => nrLDPC_cnProc_BG1_Z2_R13_AVX512.c} |    2 +-
 ...2.c => nrLDPC_cnProc_BG1_Z30_R13_AVX512.c} |    2 +-
 ....c => nrLDPC_cnProc_BG1_Z320_R13_AVX512.c} |    2 +-
 ...2.c => nrLDPC_cnProc_BG1_Z32_R13_AVX512.c} |    2 +-
 ....c => nrLDPC_cnProc_BG1_Z352_R13_AVX512.c} |    2 +-
 ...2.c => nrLDPC_cnProc_BG1_Z36_R13_AVX512.c} |    2 +-
 ....c => nrLDPC_cnProc_BG1_Z384_R13_AVX512.c} |    2 +-
 ...12.c => nrLDPC_cnProc_BG1_Z3_R13_AVX512.c} |    2 +-
 ...2.c => nrLDPC_cnProc_BG1_Z40_R13_AVX512.c} |    2 +-
 ...2.c => nrLDPC_cnProc_BG1_Z44_R13_AVX512.c} |    2 +-
 ...2.c => nrLDPC_cnProc_BG1_Z48_R13_AVX512.c} |    2 +-
 ...12.c => nrLDPC_cnProc_BG1_Z4_R13_AVX512.c} |    2 +-
 ...2.c => nrLDPC_cnProc_BG1_Z52_R13_AVX512.c} |    2 +-
 ...2.c => nrLDPC_cnProc_BG1_Z56_R13_AVX512.c} |    2 +-
 ...12.c => nrLDPC_cnProc_BG1_Z5_R13_AVX512.c} |    2 +-
 ...2.c => nrLDPC_cnProc_BG1_Z60_R13_AVX512.c} |    2 +-
 ...2.c => nrLDPC_cnProc_BG1_Z64_R13_AVX512.c} |    2 +-
 ...12.c => nrLDPC_cnProc_BG1_Z6_R13_AVX512.c} |    2 +-
 ...2.c => nrLDPC_cnProc_BG1_Z72_R13_AVX512.c} |    2 +-
 ...12.c => nrLDPC_cnProc_BG1_Z7_R13_AVX512.c} |    2 +-
 ...2.c => nrLDPC_cnProc_BG1_Z80_R13_AVX512.c} |    2 +-
 ...2.c => nrLDPC_cnProc_BG1_Z88_R13_AVX512.c} |    2 +-
 ...12.c => nrLDPC_cnProc_BG1_Z8_R13_AVX512.c} |    2 +-
 ...2.c => nrLDPC_cnProc_BG1_Z96_R13_AVX512.c} |    2 +-
 ...12.c => nrLDPC_cnProc_BG1_Z9_R13_AVX512.c} |    2 +-
 ....c => nrLDPC_cnProc_BG2_Z104_R15_AVX512.c} |    2 +-
 ...2.c => nrLDPC_cnProc_BG2_Z10_R15_AVX512.c} |    2 +-
 ....c => nrLDPC_cnProc_BG2_Z112_R15_AVX512.c} |    2 +-
 ...2.c => nrLDPC_cnProc_BG2_Z11_R15_AVX512.c} |    2 +-
 ....c => nrLDPC_cnProc_BG2_Z120_R15_AVX512.c} |    2 +-
 ....c => nrLDPC_cnProc_BG2_Z128_R15_AVX512.c} |    2 +-
 ...2.c => nrLDPC_cnProc_BG2_Z12_R15_AVX512.c} |    2 +-
 ...2.c => nrLDPC_cnProc_BG2_Z13_R15_AVX512.c} |    2 +-
 ....c => nrLDPC_cnProc_BG2_Z144_R15_AVX512.c} |    2 +-
 ...2.c => nrLDPC_cnProc_BG2_Z14_R15_AVX512.c} |    2 +-
 ...2.c => nrLDPC_cnProc_BG2_Z15_R15_AVX512.c} |    2 +-
 ....c => nrLDPC_cnProc_BG2_Z160_R15_AVX512.c} |    2 +-
 ...2.c => nrLDPC_cnProc_BG2_Z16_R15_AVX512.c} |    2 +-
 ....c => nrLDPC_cnProc_BG2_Z176_R15_AVX512.c} |    2 +-
 ...2.c => nrLDPC_cnProc_BG2_Z18_R15_AVX512.c} |    2 +-
 ....c => nrLDPC_cnProc_BG2_Z192_R15_AVX512.c} |    2 +-
 ....c => nrLDPC_cnProc_BG2_Z208_R15_AVX512.c} |    2 +-
 ...2.c => nrLDPC_cnProc_BG2_Z20_R15_AVX512.c} |    2 +-
 ....c => nrLDPC_cnProc_BG2_Z224_R15_AVX512.c} |    2 +-
 ...2.c => nrLDPC_cnProc_BG2_Z22_R15_AVX512.c} |    2 +-
 ....c => nrLDPC_cnProc_BG2_Z240_R15_AVX512.c} |    2 +-
 ...2.c => nrLDPC_cnProc_BG2_Z24_R15_AVX512.c} |    2 +-
 ....c => nrLDPC_cnProc_BG2_Z256_R15_AVX512.c} |    2 +-
 ...2.c => nrLDPC_cnProc_BG2_Z26_R15_AVX512.c} |    2 +-
 ....c => nrLDPC_cnProc_BG2_Z288_R15_AVX512.c} |    2 +-
 ...2.c => nrLDPC_cnProc_BG2_Z28_R15_AVX512.c} |    2 +-
 ...12.c => nrLDPC_cnProc_BG2_Z2_R15_AVX512.c} |    2 +-
 ...2.c => nrLDPC_cnProc_BG2_Z30_R15_AVX512.c} |    2 +-
 ....c => nrLDPC_cnProc_BG2_Z320_R15_AVX512.c} |    2 +-
 ...2.c => nrLDPC_cnProc_BG2_Z32_R15_AVX512.c} |    2 +-
 ....c => nrLDPC_cnProc_BG2_Z352_R15_AVX512.c} |    2 +-
 ...2.c => nrLDPC_cnProc_BG2_Z36_R15_AVX512.c} |    2 +-
 ....c => nrLDPC_cnProc_BG2_Z384_R15_AVX512.c} |    2 +-
 ...12.c => nrLDPC_cnProc_BG2_Z3_R15_AVX512.c} |    2 +-
 ...2.c => nrLDPC_cnProc_BG2_Z40_R15_AVX512.c} |    2 +-
 ...2.c => nrLDPC_cnProc_BG2_Z44_R15_AVX512.c} |    2 +-
 ...2.c => nrLDPC_cnProc_BG2_Z48_R15_AVX512.c} |    2 +-
 ...12.c => nrLDPC_cnProc_BG2_Z4_R15_AVX512.c} |    2 +-
 ...2.c => nrLDPC_cnProc_BG2_Z52_R15_AVX512.c} |    2 +-
 ...2.c => nrLDPC_cnProc_BG2_Z56_R15_AVX512.c} |    2 +-
 ...12.c => nrLDPC_cnProc_BG2_Z5_R15_AVX512.c} |    2 +-
 ...2.c => nrLDPC_cnProc_BG2_Z60_R15_AVX512.c} |    2 +-
 ...2.c => nrLDPC_cnProc_BG2_Z64_R15_AVX512.c} |    2 +-
 ...12.c => nrLDPC_cnProc_BG2_Z6_R15_AVX512.c} |    2 +-
 ...2.c => nrLDPC_cnProc_BG2_Z72_R15_AVX512.c} |    2 +-
 ...12.c => nrLDPC_cnProc_BG2_Z7_R15_AVX512.c} |    2 +-
 ...2.c => nrLDPC_cnProc_BG2_Z80_R15_AVX512.c} |    2 +-
 ...2.c => nrLDPC_cnProc_BG2_Z88_R15_AVX512.c} |    2 +-
 ...12.c => nrLDPC_cnProc_BG2_Z8_R15_AVX512.c} |    2 +-
 ...2.c => nrLDPC_cnProc_BG2_Z96_R15_AVX512.c} |    2 +-
 ...12.c => nrLDPC_cnProc_BG2_Z9_R15_AVX512.c} |    2 +-
 446 files changed, 188064 insertions(+), 1343 deletions(-)
 delete mode 100644 cmake_targets/ldpctest_BG_1_Zc_176_rate_1-3_block_length_3848_maxit_5.txt
 delete mode 100644 cmake_targets/ldpctest_BG_1_Zc_320_rate_1-3_block_length_7000_maxit_5.txt
 delete mode 100644 cmake_targets/ldpctest_BG_1_Zc_384_rate_1-3_block_length_8000_maxit_5.txt
 delete mode 100644 cmake_targets/ldpctest_BG_1_Zc_384_rate_1-3_block_length_8400_maxit_5.txt
 delete mode 100644 cmake_targets/ldpctest_BG_1_Zc_384_rate_1-3_block_length_8448_maxit_10.txt
 delete mode 100644 cmake_targets/ldpctest_BG_1_Zc_384_rate_2-3_block_length_8448_maxit_5.txt
 delete mode 100644 cmake_targets/ldpctest_BG_2_Zc_2_rate_1-3_block_length_-27056_maxit_5.txt
 delete mode 100644 cmake_targets/ldpctest_BG_2_Zc_320_rate_1-3_block_length_3200_maxit_5.txt
 delete mode 100644 cmake_targets/ldpctest_BG_2_Zc_384_rate_1-3_block_length_3840_maxit_5.txt
 delete mode 100644 cmake_targets/ldpctest_BG_2_Zc_3_rate_1-3_block_length_16_maxit_5.txt
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_decoder.c.full
 delete mode 100755 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_avx2/cnProc_gen_avx2
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_bnProc/Makefile
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_bnProc/bnProcPc_gen_BG1_avx2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_bnProc/bnProcPc_gen_BG2_avx2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_bnProc/bnProc_gen_BG1_avx2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_bnProc/bnProc_gen_BG1_avx2.c.1
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_bnProc/bnProc_gen_BG2_avx2.c
 create mode 100755 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_bnProc/bnProc_gen_avx2
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_bnProc/main.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_bnProc/sauvegarde.tar.gz
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/{generator_avx2 => generator_cnProc}/Makefile (100%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/{generator_avx2 => generator_cnProc}/cnProc_gen_BG1_avx2.c (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/{generator_avx2 => generator_cnProc}/cnProc_gen_BG2_avx2.c (98%)
 create mode 100755 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_cnProc/cnProc_gen_avx2
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/{generator_avx2 => generator_cnProc}/main.c (79%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/{generator_avx512 => generator_cnProc_avx512}/Makefile (100%)
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_cnProc_avx512/cnProc_gen_BG1_avx512.2
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/{generator_avx512 => generator_cnProc_avx512}/cnProc_gen_BG1_avx512.c (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/{generator_avx512 => generator_cnProc_avx512}/cnProc_gen_BG2_avx512.c (98%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/{generator_avx512 => generator_cnProc_avx512}/cnProc_gen_avx512 (80%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/{generator_avx512 => generator_cnProc_avx512}/main.c (100%)
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_cnProc_avx512/sauvegarde.tar.gz
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z104_R13_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z10_R13_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z112_R13_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z11_R13_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z120_R13_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z128_R13_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z12_R13_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z13_R13_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z144_R13_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z14_R13_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z15_R13_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z160_R13_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z16_R13_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z176_R13_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z18_R13_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z192_R13_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z208_R13_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z20_R13_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z224_R13_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z22_R13_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z240_R13_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z24_R13_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z256_R13_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z26_R13_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z288_R13_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z28_R13_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z2_R13_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z30_R13_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z320_R13_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z32_R13_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z352_R13_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z36_R13_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z384_R13_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z3_R13_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z40_R13_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z44_R13_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z48_R13_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z4_R13_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z52_R13_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z56_R13_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z5_R13_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z60_R13_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z64_R13_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z6_R13_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z72_R13_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z7_R13_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z80_R13_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z88_R13_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z8_R13_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z96_R13_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z9_R13_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z104_R15_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z10_R15_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z112_R15_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z11_R15_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z120_R15_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z128_R15_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z12_R15_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z13_R15_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z144_R15_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z14_R15_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z15_R15_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z160_R15_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z16_R15_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z176_R15_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z18_R15_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z192_R15_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z208_R15_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z20_R15_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z224_R15_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z22_R15_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z240_R15_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z24_R15_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z256_R15_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z26_R15_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z288_R15_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z28_R15_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z2_R15_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z30_R15_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z320_R15_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z32_R15_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z352_R15_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z36_R15_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z384_R15_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z3_R15_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z40_R15_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z44_R15_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z48_R15_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z4_R15_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z52_R15_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z56_R15_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z5_R15_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z60_R15_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z64_R15_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z6_R15_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z72_R15_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z7_R15_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z80_R15_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z88_R15_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z8_R15_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z96_R15_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z9_R15_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z104_R13_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z10_R13_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z112_R13_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z11_R13_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z120_R13_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z128_R13_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z12_R13_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z13_R13_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z144_R13_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z14_R13_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z15_R13_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z160_R13_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z16_R13_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z176_R13_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z18_R13_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z192_R13_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z208_R13_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z20_R13_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z224_R13_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z22_R13_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z240_R13_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z24_R13_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z256_R13_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z26_R13_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z288_R13_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z28_R13_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z2_R13_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z30_R13_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z320_R13_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z32_R13_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z352_R13_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z36_R13_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z384_R13_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z3_R13_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z40_R13_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z44_R13_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z48_R13_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z4_R13_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z52_R13_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z56_R13_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z5_R13_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z60_R13_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z64_R13_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z6_R13_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z72_R13_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z7_R13_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z80_R13_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z88_R13_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z8_R13_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z96_R13_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z9_R13_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z104_R15_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z10_R15_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z112_R15_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z11_R15_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z120_R15_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z128_R15_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z12_R15_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z13_R15_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z144_R15_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z14_R15_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z15_R15_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z160_R15_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z16_R15_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z176_R15_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z18_R15_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z192_R15_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z208_R15_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z20_R15_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z224_R15_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z22_R15_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z240_R15_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z24_R15_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z256_R15_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z26_R15_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z288_R15_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z28_R15_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z2_R15_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z30_R15_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z320_R15_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z32_R15_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z352_R15_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z36_R15_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z384_R15_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z3_R15_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z40_R15_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z44_R15_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z48_R15_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z4_R15_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z52_R15_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z56_R15_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z5_R15_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z60_R15_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z64_R15_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z6_R15_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z72_R15_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z7_R15_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z80_R15_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z88_R15_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z8_R15_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z96_R15_AVX2.c
 create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z9_R15_AVX2.c
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{avx2/nrLDPC_cnProc_BG1_Z104_13_AVX2.c => cnProc/nrLDPC_cnProc_BG1_Z104_R13_AVX2.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{avx2/nrLDPC_cnProc_BG1_Z9_13_AVX2.c => cnProc/nrLDPC_cnProc_BG1_Z10_R13_AVX2.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{avx2/nrLDPC_cnProc_BG1_Z112_13_AVX2.c => cnProc/nrLDPC_cnProc_BG1_Z112_R13_AVX2.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{avx2/nrLDPC_cnProc_BG1_Z11_13_AVX2.c => cnProc/nrLDPC_cnProc_BG1_Z11_R13_AVX2.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{avx2/nrLDPC_cnProc_BG1_Z120_13_AVX2.c => cnProc/nrLDPC_cnProc_BG1_Z120_R13_AVX2.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{avx2/nrLDPC_cnProc_BG1_Z128_13_AVX2.c => cnProc/nrLDPC_cnProc_BG1_Z128_R13_AVX2.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{avx2/nrLDPC_cnProc_BG1_Z12_13_AVX2.c => cnProc/nrLDPC_cnProc_BG1_Z12_R13_AVX2.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{avx2/nrLDPC_cnProc_BG1_Z14_13_AVX2.c => cnProc/nrLDPC_cnProc_BG1_Z13_R13_AVX2.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{avx2/nrLDPC_cnProc_BG1_Z144_13_AVX2.c => cnProc/nrLDPC_cnProc_BG1_Z144_R13_AVX2.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{avx2/nrLDPC_cnProc_BG1_Z13_13_AVX2.c => cnProc/nrLDPC_cnProc_BG1_Z14_R13_AVX2.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{avx2/nrLDPC_cnProc_BG1_Z15_13_AVX2.c => cnProc/nrLDPC_cnProc_BG1_Z15_R13_AVX2.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{avx2/nrLDPC_cnProc_BG1_Z160_13_AVX2.c => cnProc/nrLDPC_cnProc_BG1_Z160_R13_AVX2.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{avx2/nrLDPC_cnProc_BG1_Z16_13_AVX2.c => cnProc/nrLDPC_cnProc_BG1_Z16_R13_AVX2.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{avx2/nrLDPC_cnProc_BG1_Z176_13_AVX2.c => cnProc/nrLDPC_cnProc_BG1_Z176_R13_AVX2.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{avx2/nrLDPC_cnProc_BG1_Z18_13_AVX2.c => cnProc/nrLDPC_cnProc_BG1_Z18_R13_AVX2.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{avx2/nrLDPC_cnProc_BG1_Z192_13_AVX2.c => cnProc/nrLDPC_cnProc_BG1_Z192_R13_AVX2.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{avx2/nrLDPC_cnProc_BG1_Z208_13_AVX2.c => cnProc/nrLDPC_cnProc_BG1_Z208_R13_AVX2.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{avx2/nrLDPC_cnProc_BG1_Z20_13_AVX2.c => cnProc/nrLDPC_cnProc_BG1_Z20_R13_AVX2.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{avx2/nrLDPC_cnProc_BG1_Z224_13_AVX2.c => cnProc/nrLDPC_cnProc_BG1_Z224_R13_AVX2.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{avx2/nrLDPC_cnProc_BG1_Z22_13_AVX2.c => cnProc/nrLDPC_cnProc_BG1_Z22_R13_AVX2.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{avx2/nrLDPC_cnProc_BG1_Z240_13_AVX2.c => cnProc/nrLDPC_cnProc_BG1_Z240_R13_AVX2.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{avx2/nrLDPC_cnProc_BG1_Z24_13_AVX2.c => cnProc/nrLDPC_cnProc_BG1_Z24_R13_AVX2.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{avx2/nrLDPC_cnProc_BG1_Z256_13_AVX2.c => cnProc/nrLDPC_cnProc_BG1_Z256_R13_AVX2.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{avx2/nrLDPC_cnProc_BG1_Z26_13_AVX2.c => cnProc/nrLDPC_cnProc_BG1_Z26_R13_AVX2.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{avx2/nrLDPC_cnProc_BG1_Z288_13_AVX2.c => cnProc/nrLDPC_cnProc_BG1_Z288_R13_AVX2.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{avx2/nrLDPC_cnProc_BG1_Z28_13_AVX2.c => cnProc/nrLDPC_cnProc_BG1_Z28_R13_AVX2.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{avx2/nrLDPC_cnProc_BG1_Z2_13_AVX2.c => cnProc/nrLDPC_cnProc_BG1_Z2_R13_AVX2.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{avx2/nrLDPC_cnProc_BG1_Z30_13_AVX2.c => cnProc/nrLDPC_cnProc_BG1_Z30_R13_AVX2.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{avx2/nrLDPC_cnProc_BG1_Z320_13_AVX2.c => cnProc/nrLDPC_cnProc_BG1_Z320_R13_AVX2.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{avx2/nrLDPC_cnProc_BG1_Z32_13_AVX2.c => cnProc/nrLDPC_cnProc_BG1_Z32_R13_AVX2.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{avx2/nrLDPC_cnProc_BG1_Z352_13_AVX2.c => cnProc/nrLDPC_cnProc_BG1_Z352_R13_AVX2.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{avx2/nrLDPC_cnProc_BG1_Z36_13_AVX2.c => cnProc/nrLDPC_cnProc_BG1_Z36_R13_AVX2.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{avx2/nrLDPC_cnProc_BG1_Z384_13_AVX2.c => cnProc/nrLDPC_cnProc_BG1_Z384_R13_AVX2.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{avx2/nrLDPC_cnProc_BG1_Z3_13_AVX2.c => cnProc/nrLDPC_cnProc_BG1_Z3_R13_AVX2.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{avx2/nrLDPC_cnProc_BG1_Z40_13_AVX2.c => cnProc/nrLDPC_cnProc_BG1_Z40_R13_AVX2.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{avx2/nrLDPC_cnProc_BG1_Z44_13_AVX2.c => cnProc/nrLDPC_cnProc_BG1_Z44_R13_AVX2.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{avx2/nrLDPC_cnProc_BG1_Z48_13_AVX2.c => cnProc/nrLDPC_cnProc_BG1_Z48_R13_AVX2.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{avx2/nrLDPC_cnProc_BG1_Z4_13_AVX2.c => cnProc/nrLDPC_cnProc_BG1_Z4_R13_AVX2.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{avx2/nrLDPC_cnProc_BG1_Z52_13_AVX2.c => cnProc/nrLDPC_cnProc_BG1_Z52_R13_AVX2.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{avx2/nrLDPC_cnProc_BG1_Z56_13_AVX2.c => cnProc/nrLDPC_cnProc_BG1_Z56_R13_AVX2.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{avx2/nrLDPC_cnProc_BG1_Z5_13_AVX2.c => cnProc/nrLDPC_cnProc_BG1_Z5_R13_AVX2.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{avx2/nrLDPC_cnProc_BG1_Z60_13_AVX2.c => cnProc/nrLDPC_cnProc_BG1_Z60_R13_AVX2.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{avx2/nrLDPC_cnProc_BG1_Z64_13_AVX2.c => cnProc/nrLDPC_cnProc_BG1_Z64_R13_AVX2.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{avx2/nrLDPC_cnProc_BG1_Z6_13_AVX2.c => cnProc/nrLDPC_cnProc_BG1_Z6_R13_AVX2.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{avx2/nrLDPC_cnProc_BG1_Z72_13_AVX2.c => cnProc/nrLDPC_cnProc_BG1_Z72_R13_AVX2.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{avx2/nrLDPC_cnProc_BG1_Z7_13_AVX2.c => cnProc/nrLDPC_cnProc_BG1_Z7_R13_AVX2.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{avx2/nrLDPC_cnProc_BG1_Z80_13_AVX2.c => cnProc/nrLDPC_cnProc_BG1_Z80_R13_AVX2.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{avx2/nrLDPC_cnProc_BG1_Z88_13_AVX2.c => cnProc/nrLDPC_cnProc_BG1_Z88_R13_AVX2.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{avx2/nrLDPC_cnProc_BG1_Z8_13_AVX2.c => cnProc/nrLDPC_cnProc_BG1_Z8_R13_AVX2.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{avx2/nrLDPC_cnProc_BG1_Z96_13_AVX2.c => cnProc/nrLDPC_cnProc_BG1_Z96_R13_AVX2.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{avx2/nrLDPC_cnProc_BG1_Z10_13_AVX2.c => cnProc/nrLDPC_cnProc_BG1_Z9_R13_AVX2.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{avx2/nrLDPC_cnProc_BG2_Z104_15_AVX2.c => cnProc/nrLDPC_cnProc_BG2_Z104_R15_AVX2.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{avx2/nrLDPC_cnProc_BG2_Z10_15_AVX2.c => cnProc/nrLDPC_cnProc_BG2_Z10_R15_AVX2.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{avx2/nrLDPC_cnProc_BG2_Z112_15_AVX2.c => cnProc/nrLDPC_cnProc_BG2_Z112_R15_AVX2.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{avx2/nrLDPC_cnProc_BG2_Z11_15_AVX2.c => cnProc/nrLDPC_cnProc_BG2_Z11_R15_AVX2.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{avx2/nrLDPC_cnProc_BG2_Z120_15_AVX2.c => cnProc/nrLDPC_cnProc_BG2_Z120_R15_AVX2.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{avx2/nrLDPC_cnProc_BG2_Z128_15_AVX2.c => cnProc/nrLDPC_cnProc_BG2_Z128_R15_AVX2.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{avx2/nrLDPC_cnProc_BG2_Z12_15_AVX2.c => cnProc/nrLDPC_cnProc_BG2_Z12_R15_AVX2.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{avx2/nrLDPC_cnProc_BG2_Z14_15_AVX2.c => cnProc/nrLDPC_cnProc_BG2_Z13_R15_AVX2.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{avx2/nrLDPC_cnProc_BG2_Z144_15_AVX2.c => cnProc/nrLDPC_cnProc_BG2_Z144_R15_AVX2.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{avx2/nrLDPC_cnProc_BG2_Z13_15_AVX2.c => cnProc/nrLDPC_cnProc_BG2_Z14_R15_AVX2.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{avx2/nrLDPC_cnProc_BG2_Z15_15_AVX2.c => cnProc/nrLDPC_cnProc_BG2_Z15_R15_AVX2.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{avx2/nrLDPC_cnProc_BG2_Z160_15_AVX2.c => cnProc/nrLDPC_cnProc_BG2_Z160_R15_AVX2.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{avx2/nrLDPC_cnProc_BG2_Z16_15_AVX2.c => cnProc/nrLDPC_cnProc_BG2_Z16_R15_AVX2.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{avx2/nrLDPC_cnProc_BG2_Z176_15_AVX2.c => cnProc/nrLDPC_cnProc_BG2_Z176_R15_AVX2.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{avx2/nrLDPC_cnProc_BG2_Z18_15_AVX2.c => cnProc/nrLDPC_cnProc_BG2_Z18_R15_AVX2.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{avx2/nrLDPC_cnProc_BG2_Z192_15_AVX2.c => cnProc/nrLDPC_cnProc_BG2_Z192_R15_AVX2.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{avx2/nrLDPC_cnProc_BG2_Z208_15_AVX2.c => cnProc/nrLDPC_cnProc_BG2_Z208_R15_AVX2.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{avx2/nrLDPC_cnProc_BG2_Z20_15_AVX2.c => cnProc/nrLDPC_cnProc_BG2_Z20_R15_AVX2.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{avx2/nrLDPC_cnProc_BG2_Z224_15_AVX2.c => cnProc/nrLDPC_cnProc_BG2_Z224_R15_AVX2.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{avx2/nrLDPC_cnProc_BG2_Z22_15_AVX2.c => cnProc/nrLDPC_cnProc_BG2_Z22_R15_AVX2.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{avx2/nrLDPC_cnProc_BG2_Z240_15_AVX2.c => cnProc/nrLDPC_cnProc_BG2_Z240_R15_AVX2.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{avx2/nrLDPC_cnProc_BG2_Z24_15_AVX2.c => cnProc/nrLDPC_cnProc_BG2_Z24_R15_AVX2.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{avx2/nrLDPC_cnProc_BG2_Z256_15_AVX2.c => cnProc/nrLDPC_cnProc_BG2_Z256_R15_AVX2.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{avx2/nrLDPC_cnProc_BG2_Z26_15_AVX2.c => cnProc/nrLDPC_cnProc_BG2_Z26_R15_AVX2.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{avx2/nrLDPC_cnProc_BG2_Z288_15_AVX2.c => cnProc/nrLDPC_cnProc_BG2_Z288_R15_AVX2.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{avx2/nrLDPC_cnProc_BG2_Z28_15_AVX2.c => cnProc/nrLDPC_cnProc_BG2_Z28_R15_AVX2.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{avx2/nrLDPC_cnProc_BG2_Z2_15_AVX2.c => cnProc/nrLDPC_cnProc_BG2_Z2_R15_AVX2.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{avx2/nrLDPC_cnProc_BG2_Z30_15_AVX2.c => cnProc/nrLDPC_cnProc_BG2_Z30_R15_AVX2.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{avx2/nrLDPC_cnProc_BG2_Z320_15_AVX2.c => cnProc/nrLDPC_cnProc_BG2_Z320_R15_AVX2.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{avx2/nrLDPC_cnProc_BG2_Z32_15_AVX2.c => cnProc/nrLDPC_cnProc_BG2_Z32_R15_AVX2.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{avx2/nrLDPC_cnProc_BG2_Z352_15_AVX2.c => cnProc/nrLDPC_cnProc_BG2_Z352_R15_AVX2.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{avx2/nrLDPC_cnProc_BG2_Z36_15_AVX2.c => cnProc/nrLDPC_cnProc_BG2_Z36_R15_AVX2.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{avx2/nrLDPC_cnProc_BG2_Z384_15_AVX2.c => cnProc/nrLDPC_cnProc_BG2_Z384_R15_AVX2.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{avx2/nrLDPC_cnProc_BG2_Z3_15_AVX2.c => cnProc/nrLDPC_cnProc_BG2_Z3_R15_AVX2.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{avx2/nrLDPC_cnProc_BG2_Z40_15_AVX2.c => cnProc/nrLDPC_cnProc_BG2_Z40_R15_AVX2.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{avx2/nrLDPC_cnProc_BG2_Z44_15_AVX2.c => cnProc/nrLDPC_cnProc_BG2_Z44_R15_AVX2.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{avx2/nrLDPC_cnProc_BG2_Z48_15_AVX2.c => cnProc/nrLDPC_cnProc_BG2_Z48_R15_AVX2.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{avx2/nrLDPC_cnProc_BG2_Z4_15_AVX2.c => cnProc/nrLDPC_cnProc_BG2_Z4_R15_AVX2.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{avx2/nrLDPC_cnProc_BG2_Z52_15_AVX2.c => cnProc/nrLDPC_cnProc_BG2_Z52_R15_AVX2.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{avx2/nrLDPC_cnProc_BG2_Z56_15_AVX2.c => cnProc/nrLDPC_cnProc_BG2_Z56_R15_AVX2.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{avx2/nrLDPC_cnProc_BG2_Z5_15_AVX2.c => cnProc/nrLDPC_cnProc_BG2_Z5_R15_AVX2.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{avx2/nrLDPC_cnProc_BG2_Z60_15_AVX2.c => cnProc/nrLDPC_cnProc_BG2_Z60_R15_AVX2.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{avx2/nrLDPC_cnProc_BG2_Z64_15_AVX2.c => cnProc/nrLDPC_cnProc_BG2_Z64_R15_AVX2.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{avx2/nrLDPC_cnProc_BG2_Z6_15_AVX2.c => cnProc/nrLDPC_cnProc_BG2_Z6_R15_AVX2.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{avx2/nrLDPC_cnProc_BG2_Z72_15_AVX2.c => cnProc/nrLDPC_cnProc_BG2_Z72_R15_AVX2.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{avx2/nrLDPC_cnProc_BG2_Z7_15_AVX2.c => cnProc/nrLDPC_cnProc_BG2_Z7_R15_AVX2.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{avx2/nrLDPC_cnProc_BG2_Z80_15_AVX2.c => cnProc/nrLDPC_cnProc_BG2_Z80_R15_AVX2.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{avx2/nrLDPC_cnProc_BG2_Z88_15_AVX2.c => cnProc/nrLDPC_cnProc_BG2_Z88_R15_AVX2.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{avx2/nrLDPC_cnProc_BG2_Z8_15_AVX2.c => cnProc/nrLDPC_cnProc_BG2_Z8_R15_AVX2.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{avx2/nrLDPC_cnProc_BG2_Z96_15_AVX2.c => cnProc/nrLDPC_cnProc_BG2_Z96_R15_AVX2.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{avx2/nrLDPC_cnProc_BG2_Z9_15_AVX2.c => cnProc/nrLDPC_cnProc_BG2_Z9_R15_AVX2.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{nrLDPC_cnProc_BG1_Z104_13_AVX512.c => nrLDPC_cnProc_BG1_Z104_R13_AVX512.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{nrLDPC_cnProc_BG1_Z9_13_AVX512.c => nrLDPC_cnProc_BG1_Z10_R13_AVX512.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{nrLDPC_cnProc_BG1_Z112_13_AVX512.c => nrLDPC_cnProc_BG1_Z112_R13_AVX512.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{nrLDPC_cnProc_BG1_Z12_13_AVX512.c => nrLDPC_cnProc_BG1_Z11_R13_AVX512.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{nrLDPC_cnProc_BG1_Z120_13_AVX512.c => nrLDPC_cnProc_BG1_Z120_R13_AVX512.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{nrLDPC_cnProc_BG1_Z128_13_AVX512.c => nrLDPC_cnProc_BG1_Z128_R13_AVX512.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{nrLDPC_cnProc_BG1_Z11_13_AVX512.c => nrLDPC_cnProc_BG1_Z12_R13_AVX512.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{nrLDPC_cnProc_BG1_Z13_13_AVX512.c => nrLDPC_cnProc_BG1_Z13_R13_AVX512.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{nrLDPC_cnProc_BG1_Z144_13_AVX512.c => nrLDPC_cnProc_BG1_Z144_R13_AVX512.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{nrLDPC_cnProc_BG1_Z14_13_AVX512.c => nrLDPC_cnProc_BG1_Z14_R13_AVX512.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{nrLDPC_cnProc_BG1_Z15_13_AVX512.c => nrLDPC_cnProc_BG1_Z15_R13_AVX512.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{nrLDPC_cnProc_BG1_Z160_13_AVX512.c => nrLDPC_cnProc_BG1_Z160_R13_AVX512.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{nrLDPC_cnProc_BG1_Z16_13_AVX512.c => nrLDPC_cnProc_BG1_Z16_R13_AVX512.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{nrLDPC_cnProc_BG1_Z176_13_AVX512.c => nrLDPC_cnProc_BG1_Z176_R13_AVX512.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{nrLDPC_cnProc_BG1_Z18_13_AVX512.c => nrLDPC_cnProc_BG1_Z18_R13_AVX512.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{nrLDPC_cnProc_BG1_Z192_13_AVX512.c => nrLDPC_cnProc_BG1_Z192_R13_AVX512.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{nrLDPC_cnProc_BG1_Z208_13_AVX512.c => nrLDPC_cnProc_BG1_Z208_R13_AVX512.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{nrLDPC_cnProc_BG1_Z20_13_AVX512.c => nrLDPC_cnProc_BG1_Z20_R13_AVX512.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{nrLDPC_cnProc_BG1_Z224_13_AVX512.c => nrLDPC_cnProc_BG1_Z224_R13_AVX512.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{nrLDPC_cnProc_BG1_Z22_13_AVX512.c => nrLDPC_cnProc_BG1_Z22_R13_AVX512.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{nrLDPC_cnProc_BG1_Z240_13_AVX512.c => nrLDPC_cnProc_BG1_Z240_R13_AVX512.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{nrLDPC_cnProc_BG1_Z24_13_AVX512.c => nrLDPC_cnProc_BG1_Z24_R13_AVX512.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{nrLDPC_cnProc_BG1_Z256_13_AVX512.c => nrLDPC_cnProc_BG1_Z256_R13_AVX512.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{nrLDPC_cnProc_BG1_Z26_13_AVX512.c => nrLDPC_cnProc_BG1_Z26_R13_AVX512.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{nrLDPC_cnProc_BG1_Z288_13_AVX512.c => nrLDPC_cnProc_BG1_Z288_R13_AVX512.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{nrLDPC_cnProc_BG1_Z28_13_AVX512.c => nrLDPC_cnProc_BG1_Z28_R13_AVX512.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{nrLDPC_cnProc_BG1_Z3_13_AVX512.c => nrLDPC_cnProc_BG1_Z2_R13_AVX512.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{nrLDPC_cnProc_BG1_Z30_13_AVX512.c => nrLDPC_cnProc_BG1_Z30_R13_AVX512.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{nrLDPC_cnProc_BG1_Z320_13_AVX512.c => nrLDPC_cnProc_BG1_Z320_R13_AVX512.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{nrLDPC_cnProc_BG1_Z32_13_AVX512.c => nrLDPC_cnProc_BG1_Z32_R13_AVX512.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{nrLDPC_cnProc_BG1_Z352_13_AVX512.c => nrLDPC_cnProc_BG1_Z352_R13_AVX512.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{nrLDPC_cnProc_BG1_Z36_13_AVX512.c => nrLDPC_cnProc_BG1_Z36_R13_AVX512.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{nrLDPC_cnProc_BG1_Z384_13_AVX512.c => nrLDPC_cnProc_BG1_Z384_R13_AVX512.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{nrLDPC_cnProc_BG1_Z2_13_AVX512.c => nrLDPC_cnProc_BG1_Z3_R13_AVX512.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{nrLDPC_cnProc_BG1_Z40_13_AVX512.c => nrLDPC_cnProc_BG1_Z40_R13_AVX512.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{nrLDPC_cnProc_BG1_Z44_13_AVX512.c => nrLDPC_cnProc_BG1_Z44_R13_AVX512.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{nrLDPC_cnProc_BG1_Z48_13_AVX512.c => nrLDPC_cnProc_BG1_Z48_R13_AVX512.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{nrLDPC_cnProc_BG1_Z6_13_AVX512.c => nrLDPC_cnProc_BG1_Z4_R13_AVX512.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{nrLDPC_cnProc_BG1_Z52_13_AVX512.c => nrLDPC_cnProc_BG1_Z52_R13_AVX512.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{nrLDPC_cnProc_BG1_Z56_13_AVX512.c => nrLDPC_cnProc_BG1_Z56_R13_AVX512.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{nrLDPC_cnProc_BG1_Z4_13_AVX512.c => nrLDPC_cnProc_BG1_Z5_R13_AVX512.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{nrLDPC_cnProc_BG1_Z60_13_AVX512.c => nrLDPC_cnProc_BG1_Z60_R13_AVX512.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{nrLDPC_cnProc_BG1_Z64_13_AVX512.c => nrLDPC_cnProc_BG1_Z64_R13_AVX512.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{nrLDPC_cnProc_BG1_Z5_13_AVX512.c => nrLDPC_cnProc_BG1_Z6_R13_AVX512.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{nrLDPC_cnProc_BG1_Z72_13_AVX512.c => nrLDPC_cnProc_BG1_Z72_R13_AVX512.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{nrLDPC_cnProc_BG1_Z7_13_AVX512.c => nrLDPC_cnProc_BG1_Z7_R13_AVX512.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{nrLDPC_cnProc_BG1_Z80_13_AVX512.c => nrLDPC_cnProc_BG1_Z80_R13_AVX512.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{nrLDPC_cnProc_BG1_Z88_13_AVX512.c => nrLDPC_cnProc_BG1_Z88_R13_AVX512.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{nrLDPC_cnProc_BG1_Z8_13_AVX512.c => nrLDPC_cnProc_BG1_Z8_R13_AVX512.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{nrLDPC_cnProc_BG1_Z96_13_AVX512.c => nrLDPC_cnProc_BG1_Z96_R13_AVX512.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{nrLDPC_cnProc_BG1_Z10_13_AVX512.c => nrLDPC_cnProc_BG1_Z9_R13_AVX512.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{nrLDPC_cnProc_BG2_Z104_15_AVX512.c => nrLDPC_cnProc_BG2_Z104_R15_AVX512.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{nrLDPC_cnProc_BG2_Z10_15_AVX512.c => nrLDPC_cnProc_BG2_Z10_R15_AVX512.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{nrLDPC_cnProc_BG2_Z112_15_AVX512.c => nrLDPC_cnProc_BG2_Z112_R15_AVX512.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{nrLDPC_cnProc_BG2_Z11_15_AVX512.c => nrLDPC_cnProc_BG2_Z11_R15_AVX512.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{nrLDPC_cnProc_BG2_Z120_15_AVX512.c => nrLDPC_cnProc_BG2_Z120_R15_AVX512.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{nrLDPC_cnProc_BG2_Z128_15_AVX512.c => nrLDPC_cnProc_BG2_Z128_R15_AVX512.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{nrLDPC_cnProc_BG2_Z12_15_AVX512.c => nrLDPC_cnProc_BG2_Z12_R15_AVX512.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{nrLDPC_cnProc_BG2_Z14_15_AVX512.c => nrLDPC_cnProc_BG2_Z13_R15_AVX512.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{nrLDPC_cnProc_BG2_Z144_15_AVX512.c => nrLDPC_cnProc_BG2_Z144_R15_AVX512.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{nrLDPC_cnProc_BG2_Z13_15_AVX512.c => nrLDPC_cnProc_BG2_Z14_R15_AVX512.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{nrLDPC_cnProc_BG2_Z15_15_AVX512.c => nrLDPC_cnProc_BG2_Z15_R15_AVX512.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{nrLDPC_cnProc_BG2_Z160_15_AVX512.c => nrLDPC_cnProc_BG2_Z160_R15_AVX512.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{nrLDPC_cnProc_BG2_Z16_15_AVX512.c => nrLDPC_cnProc_BG2_Z16_R15_AVX512.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{nrLDPC_cnProc_BG2_Z176_15_AVX512.c => nrLDPC_cnProc_BG2_Z176_R15_AVX512.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{nrLDPC_cnProc_BG2_Z18_15_AVX512.c => nrLDPC_cnProc_BG2_Z18_R15_AVX512.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{nrLDPC_cnProc_BG2_Z192_15_AVX512.c => nrLDPC_cnProc_BG2_Z192_R15_AVX512.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{nrLDPC_cnProc_BG2_Z208_15_AVX512.c => nrLDPC_cnProc_BG2_Z208_R15_AVX512.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{nrLDPC_cnProc_BG2_Z20_15_AVX512.c => nrLDPC_cnProc_BG2_Z20_R15_AVX512.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{nrLDPC_cnProc_BG2_Z224_15_AVX512.c => nrLDPC_cnProc_BG2_Z224_R15_AVX512.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{nrLDPC_cnProc_BG2_Z22_15_AVX512.c => nrLDPC_cnProc_BG2_Z22_R15_AVX512.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{nrLDPC_cnProc_BG2_Z240_15_AVX512.c => nrLDPC_cnProc_BG2_Z240_R15_AVX512.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{nrLDPC_cnProc_BG2_Z24_15_AVX512.c => nrLDPC_cnProc_BG2_Z24_R15_AVX512.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{nrLDPC_cnProc_BG2_Z256_15_AVX512.c => nrLDPC_cnProc_BG2_Z256_R15_AVX512.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{nrLDPC_cnProc_BG2_Z26_15_AVX512.c => nrLDPC_cnProc_BG2_Z26_R15_AVX512.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{nrLDPC_cnProc_BG2_Z288_15_AVX512.c => nrLDPC_cnProc_BG2_Z288_R15_AVX512.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{nrLDPC_cnProc_BG2_Z28_15_AVX512.c => nrLDPC_cnProc_BG2_Z28_R15_AVX512.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{nrLDPC_cnProc_BG2_Z2_15_AVX512.c => nrLDPC_cnProc_BG2_Z2_R15_AVX512.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{nrLDPC_cnProc_BG2_Z30_15_AVX512.c => nrLDPC_cnProc_BG2_Z30_R15_AVX512.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{nrLDPC_cnProc_BG2_Z320_15_AVX512.c => nrLDPC_cnProc_BG2_Z320_R15_AVX512.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{nrLDPC_cnProc_BG2_Z32_15_AVX512.c => nrLDPC_cnProc_BG2_Z32_R15_AVX512.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{nrLDPC_cnProc_BG2_Z352_15_AVX512.c => nrLDPC_cnProc_BG2_Z352_R15_AVX512.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{nrLDPC_cnProc_BG2_Z36_15_AVX512.c => nrLDPC_cnProc_BG2_Z36_R15_AVX512.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{nrLDPC_cnProc_BG2_Z384_15_AVX512.c => nrLDPC_cnProc_BG2_Z384_R15_AVX512.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{nrLDPC_cnProc_BG2_Z3_15_AVX512.c => nrLDPC_cnProc_BG2_Z3_R15_AVX512.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{nrLDPC_cnProc_BG2_Z40_15_AVX512.c => nrLDPC_cnProc_BG2_Z40_R15_AVX512.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{nrLDPC_cnProc_BG2_Z44_15_AVX512.c => nrLDPC_cnProc_BG2_Z44_R15_AVX512.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{nrLDPC_cnProc_BG2_Z48_15_AVX512.c => nrLDPC_cnProc_BG2_Z48_R15_AVX512.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{nrLDPC_cnProc_BG2_Z6_15_AVX512.c => nrLDPC_cnProc_BG2_Z4_R15_AVX512.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{nrLDPC_cnProc_BG2_Z52_15_AVX512.c => nrLDPC_cnProc_BG2_Z52_R15_AVX512.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{nrLDPC_cnProc_BG2_Z56_15_AVX512.c => nrLDPC_cnProc_BG2_Z56_R15_AVX512.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{nrLDPC_cnProc_BG2_Z4_15_AVX512.c => nrLDPC_cnProc_BG2_Z5_R15_AVX512.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{nrLDPC_cnProc_BG2_Z60_15_AVX512.c => nrLDPC_cnProc_BG2_Z60_R15_AVX512.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{nrLDPC_cnProc_BG2_Z64_15_AVX512.c => nrLDPC_cnProc_BG2_Z64_R15_AVX512.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{nrLDPC_cnProc_BG2_Z5_15_AVX512.c => nrLDPC_cnProc_BG2_Z6_R15_AVX512.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{nrLDPC_cnProc_BG2_Z72_15_AVX512.c => nrLDPC_cnProc_BG2_Z72_R15_AVX512.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{nrLDPC_cnProc_BG2_Z7_15_AVX512.c => nrLDPC_cnProc_BG2_Z7_R15_AVX512.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{nrLDPC_cnProc_BG2_Z80_15_AVX512.c => nrLDPC_cnProc_BG2_Z80_R15_AVX512.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{nrLDPC_cnProc_BG2_Z88_15_AVX512.c => nrLDPC_cnProc_BG2_Z88_R15_AVX512.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{nrLDPC_cnProc_BG2_Z8_15_AVX512.c => nrLDPC_cnProc_BG2_Z8_R15_AVX512.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{nrLDPC_cnProc_BG2_Z96_15_AVX512.c => nrLDPC_cnProc_BG2_Z96_R15_AVX512.c} (99%)
 rename openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/{nrLDPC_cnProc_BG2_Z9_15_AVX512.c => nrLDPC_cnProc_BG2_Z9_R15_AVX512.c} (99%)

diff --git a/cmake_targets/CMakeLists.txt b/cmake_targets/CMakeLists.txt
index c9307733b7..51ec0bc4d7 100644
--- a/cmake_targets/CMakeLists.txt
+++ b/cmake_targets/CMakeLists.txt
@@ -139,7 +139,7 @@ else (CMAKE_SYSTEM_PROCESSOR STREQUAL "armv7l")
   if(EXISTS  "/proc/cpuinfo")
     file(STRINGS "/proc/cpuinfo" CPUINFO REGEX flags LIMIT_COUNT 1)
     if (CPUINFO MATCHES "avx512bw")
-      set(C_FLAGS_PROCESSOR "${C_FLAGS_PROCESSOR} -mavx512bw -march=skylake-avx512 -mtune=skylake-avx512" )
+      set(C_FLAGS_PROCESSOR "${C_FLAGS_PROCESSOR} -mavx512bw -march=skylake-avx512 -mtune=skylake-avx512 " )
       set(COMPILATION_AVX2 "True")
     else()
       if (CPUINFO MATCHES "avx2")
diff --git a/cmake_targets/ldpctest_BG_1_Zc_176_rate_1-3_block_length_3848_maxit_5.txt b/cmake_targets/ldpctest_BG_1_Zc_176_rate_1-3_block_length_3848_maxit_5.txt
deleted file mode 100644
index e69de29bb2..0000000000
diff --git a/cmake_targets/ldpctest_BG_1_Zc_320_rate_1-3_block_length_7000_maxit_5.txt b/cmake_targets/ldpctest_BG_1_Zc_320_rate_1-3_block_length_7000_maxit_5.txt
deleted file mode 100644
index e69de29bb2..0000000000
diff --git a/cmake_targets/ldpctest_BG_1_Zc_384_rate_1-3_block_length_8000_maxit_5.txt b/cmake_targets/ldpctest_BG_1_Zc_384_rate_1-3_block_length_8000_maxit_5.txt
deleted file mode 100644
index e69de29bb2..0000000000
diff --git a/cmake_targets/ldpctest_BG_1_Zc_384_rate_1-3_block_length_8400_maxit_5.txt b/cmake_targets/ldpctest_BG_1_Zc_384_rate_1-3_block_length_8400_maxit_5.txt
deleted file mode 100644
index e69de29bb2..0000000000
diff --git a/cmake_targets/ldpctest_BG_1_Zc_384_rate_1-3_block_length_8448_maxit_10.txt b/cmake_targets/ldpctest_BG_1_Zc_384_rate_1-3_block_length_8448_maxit_10.txt
deleted file mode 100644
index e69de29bb2..0000000000
diff --git a/cmake_targets/ldpctest_BG_1_Zc_384_rate_1-3_block_length_8448_maxit_5.txt b/cmake_targets/ldpctest_BG_1_Zc_384_rate_1-3_block_length_8448_maxit_5.txt
index 187904c0ab..bb75af1367 100644
--- a/cmake_targets/ldpctest_BG_1_Zc_384_rate_1-3_block_length_8448_maxit_5.txt
+++ b/cmake_targets/ldpctest_BG_1_Zc_384_rate_1-3_block_length_8448_maxit_5.txt
@@ -1,58 +1,65 @@
 SNR BLER BER UNCODED_BER ENCODER_MEAN ENCODER_STD ENCODER_MAX DECODER_TIME_MEAN DECODER_TIME_STD DECODER_TIME_MAX DECODER_ITER_MEAN DECODER_ITER_STD DECODER_ITER_MAX
--2.000000 1.000000 0.347893 0.258602 345.413345 0.000004 345.413345 381.327587 0.000008 381.327587 5.000000 0.000000 5 
--1.900000 1.000000 0.342330 0.248501 50.433975 -nan 50.433975 303.603786 0.000004 303.603786 5.000000 0.000000 5 
--1.800000 1.000000 0.331676 0.251618 45.912247 -nan 45.912247 299.675187 -nan 299.675187 5.000000 0.000000 5 
--1.700000 1.000000 0.347538 0.250592 43.845468 0.000001 43.845468 309.496757 0.000002 309.496757 5.000000 0.000000 5 
--1.600000 1.000000 0.330374 0.240728 42.153623 -nan 42.153623 298.761092 0.000005 298.761092 5.000000 0.000000 5 
--1.500000 1.000000 0.337950 0.241990 40.885619 -nan 40.885619 309.676632 0.000003 309.676632 5.000000 0.000000 5 
--1.400000 1.000000 0.328007 0.242661 40.818426 0.000001 40.818426 297.890119 -nan 297.890119 5.000000 0.000000 5 
--1.300000 1.000000 0.334162 0.242543 42.224997 -nan 42.224997 300.635954 0.000004 300.635954 5.000000 0.000000 5 
--1.200000 1.000000 0.326823 0.239504 41.281892 0.000000 41.281892 311.391067 0.000004 311.391067 5.000000 0.000000 5 
--1.100000 1.000000 0.327888 0.234020 41.594545 0.000000 41.594545 299.677245 0.000004 299.677245 5.000000 0.000000 5 
--1.000000 1.000000 0.319010 0.237374 41.687210 0.000001 41.687210 312.381757 0.000002 312.381757 5.000000 0.000000 5 
--0.900000 1.000000 0.331439 0.238202 41.645207 0.000000 41.645207 300.158539 0.000002 300.158539 5.000000 0.000000 5 
--0.800000 1.000000 0.317945 0.228220 41.391902 0.000000 41.391902 299.700647 0.000004 299.700647 5.000000 0.000000 5 
--0.700000 1.000000 0.334280 0.224708 42.384978 -nan 42.384978 298.769362 0.000003 298.769362 5.000000 0.000000 5 
--0.600000 1.000000 0.299006 0.219579 42.773106 -nan 42.773106 299.787052 -nan 299.787052 5.000000 0.000000 5 
--0.500000 1.000000 0.318774 0.220644 41.325048 0.000000 41.325048 316.815372 0.000002 316.815372 5.000000 0.000000 5 
--0.400000 1.000000 0.303385 0.218513 42.267662 -nan 42.267662 297.842164 0.000000 297.842164 5.000000 0.000000 5 
--0.300000 1.000000 0.318300 0.214489 40.771762 0.000001 40.771762 298.690724 -nan 298.690724 5.000000 0.000000 5 
--0.200000 1.000000 0.288944 0.210543 43.190243 -nan 43.190243 297.980015 0.000004 297.980015 5.000000 0.000000 5 
--0.100000 1.000000 0.301373 0.213187 42.336492 0.000001 42.336492 299.350576 0.000003 299.350576 5.000000 0.000000 5 
-0.000000 1.000000 0.285038 0.205216 42.349820 -nan 42.349820 307.925299 0.000005 307.925299 5.000000 0.000000 5 
-0.100000 1.000000 0.288707 0.205650 41.676366 0.000000 41.676366 299.765988 0.000003 299.765988 5.000000 0.000000 5 
-0.200000 1.000000 0.288826 0.204506 100.891392 -nan 100.891392 312.470803 -nan 312.470803 5.000000 0.000000 5 
-0.300000 1.000000 0.293561 0.202099 75.597190 -nan 75.597190 300.678868 -nan 300.678868 5.000000 0.000000 5 
-0.400000 1.000000 0.261009 0.194444 55.588598 0.000000 55.588598 311.268286 0.000003 311.268286 5.000000 0.000000 5 
-0.500000 1.000000 0.254025 0.192945 41.310789 0.000000 41.310789 300.349503 0.000001 300.349503 5.000000 0.000000 5 
-0.600000 1.000000 0.264560 0.195234 41.309234 -nan 41.309234 309.563935 -nan 309.563935 5.000000 0.000000 5 
-0.700000 1.000000 0.263021 0.190696 40.962137 -nan 40.962137 299.080861 -nan 299.080861 5.000000 0.000000 5 
-0.800000 1.000000 0.234967 0.185567 40.948828 0.000000 40.948828 298.705728 -nan 298.705728 5.000000 0.000000 5 
-0.900000 1.000000 0.208688 0.181305 40.738823 -nan 40.738823 306.477783 0.000003 306.477783 5.000000 0.000000 5 
-1.000000 1.000000 0.220526 0.182410 41.767858 0.000000 41.767858 300.293807 -nan 300.293807 5.000000 0.000000 5 
-1.100000 1.000000 0.195076 0.176176 41.232798 0.000000 41.232798 324.354057 0.000004 324.354057 5.000000 0.000000 5 
-1.200000 1.000000 0.174598 0.170889 40.813436 0.000001 40.813436 298.380591 -nan 298.380591 5.000000 0.000000 5 
-1.300000 1.000000 0.185724 0.172546 45.371795 0.000000 45.371795 301.953555 0.000003 301.953555 5.000000 0.000000 5 
-1.400000 1.000000 0.159446 0.172704 40.402160 0.000000 40.402160 307.144539 0.000004 307.144539 5.000000 0.000000 5 
-1.500000 1.000000 0.106179 0.160906 41.177388 -nan 41.177388 300.853580 -nan 300.853580 5.000000 0.000000 5 
-1.600000 1.000000 0.129735 0.162879 41.402803 0.000001 41.402803 299.876336 0.000004 299.876336 5.000000 0.000000 5 
-1.700000 1.000000 0.106889 0.158460 40.716819 -nan 40.716819 330.484923 0.000004 330.484923 5.000000 0.000000 5 
-1.800000 1.000000 0.090554 0.156132 41.886107 0.000001 41.886107 299.725683 0.000002 299.725683 5.000000 0.000000 5 
-1.900000 1.000000 0.078717 0.150489 40.852836 -nan 40.852836 300.706948 -nan 300.706948 5.000000 0.000000 5 
-2.000000 1.000000 0.058357 0.152817 41.219907 0.000000 41.219907 299.323293 0.000004 299.323293 5.000000 0.000000 5 
-2.100000 1.000000 0.042377 0.144689 41.417887 -nan 41.417887 301.167789 -nan 301.167789 5.000000 0.000000 5 
-2.200000 1.000000 0.034091 0.144255 41.088578 -nan 41.088578 300.078545 -nan 300.078545 5.000000 0.000000 5 
-2.300000 1.000000 0.028883 0.141769 40.788108 0.000001 40.788108 299.349223 -nan 299.349223 5.000000 0.000000 5 
-2.400000 1.000000 0.017992 0.137745 40.596133 -nan 40.596133 299.495972 0.000003 299.495972 5.000000 0.000000 5 
-2.500000 1.000000 0.015152 0.140309 40.886604 -nan 40.886604 300.679262 0.000001 300.679262 5.000000 0.000000 5 
-2.600000 1.000000 0.012547 0.136127 40.733922 0.000001 40.733922 299.853799 0.000003 299.853799 5.000000 0.000000 5 
-2.700000 1.000000 0.004498 0.128985 40.587111 0.000000 40.587111 299.787993 -nan 299.787993 5.000000 0.000000 5 
-2.800000 1.000000 0.012311 0.131076 39.997159 0.000000 39.997159 299.736713 0.000004 299.736713 5.000000 0.000000 5 
-2.900000 1.000000 0.003196 0.125158 41.180559 -nan 41.180559 299.685145 0.000004 299.685145 5.000000 0.000000 5 
-3.000000 1.000000 0.003314 0.125592 40.826417 -nan 40.826417 306.487443 -nan 306.487443 5.000000 0.000000 5 
-3.100000 1.000000 0.003078 0.123382 41.185242 0.000001 41.185242 300.970511 0.000002 300.970511 5.000000 0.000000 5 
-3.200000 1.000000 0.001302 0.119200 40.848441 -nan 40.848441 299.774774 -nan 299.774774 5.000000 0.000000 5 
-3.300000 1.000000 0.002249 0.116438 41.450744 0.000000 41.450744 313.562416 0.000003 313.562416 5.000000 0.000000 5 
-3.400000 1.000000 0.000592 0.111979 41.094820 -nan 41.094820 301.054252 0.000002 301.054252 5.000000 0.000000 5 
-3.500000 1.000000 0.000237 0.110598 40.427126 -nan 40.427126 299.461379 0.000003 299.461379 5.000000 0.000000 5 
-3.600000 0.000000 0.000000 0.110361 40.306813 0.000001 40.306813 305.353571 -nan 305.353571 5.000000 0.000000 5 
+-2.000000 1.000000 0.346710 0.258207 43.602415 30.126226 341.472109 216.438613 10.939821 319.554933 5.000000 0.000000 5 
+-1.900000 1.000000 0.344876 0.255716 41.206220 4.019975 56.843517 216.302939 3.270367 233.994957 5.000000 0.000000 5 
+-1.800000 1.000000 0.342785 0.253097 40.851186 3.896434 56.430195 215.430289 4.428097 246.536045 5.000000 0.000000 5 
+-1.700000 1.000000 0.340844 0.251049 40.901418 3.745278 64.127024 215.529577 4.618868 240.568501 5.000000 0.000000 5 
+-1.600000 1.000000 0.339047 0.248977 41.431427 4.101305 57.556777 215.147073 3.634402 238.697868 5.000000 0.000000 5 
+-1.500000 1.000000 0.336629 0.246285 41.620505 4.581042 57.739456 215.078678 3.846847 238.079346 5.000000 0.000000 5 
+-1.400000 1.000000 0.335457 0.243642 41.387865 4.240439 57.124142 215.228245 3.647046 236.904668 5.000000 0.000000 5 
+-1.300000 1.000000 0.332997 0.241009 41.443562 4.371919 57.671402 215.273786 3.292128 232.785466 5.000000 0.000000 5 
+-1.200000 1.000000 0.330665 0.238534 40.812640 3.650784 56.246234 214.904536 3.893906 244.015660 5.000000 0.000000 5 
+-1.100000 1.000000 0.329331 0.236302 40.565430 3.404037 56.668872 215.151626 4.975081 244.228979 5.000000 0.000000 5 
+-1.000000 1.000000 0.326340 0.233799 40.984374 3.867443 58.055435 214.392230 2.357469 220.968495 5.000000 0.000000 5 
+-0.900000 1.000000 0.324751 0.230838 40.863863 4.143883 64.125643 215.614137 5.189590 242.780171 5.000000 0.000000 5 
+-0.800000 1.000000 0.321135 0.228471 40.470152 3.513784 57.612116 214.727859 3.845100 242.821632 5.000000 0.000000 5 
+-0.700000 1.000000 0.318744 0.225573 41.309409 4.026191 57.778096 214.920451 4.535966 242.414953 5.000000 0.000000 5 
+-0.600000 1.000000 0.316129 0.222700 41.204626 3.124997 56.968813 215.387771 4.057238 237.436606 5.000000 0.000000 5 
+-0.500000 1.000000 0.314128 0.220380 40.765115 3.394491 56.267980 215.377921 4.069656 240.466822 5.000000 0.000000 5 
+-0.400000 1.000000 0.310958 0.218014 41.093157 4.003835 59.711327 215.239180 3.327907 234.288949 5.000000 0.000000 5 
+-0.300000 1.000000 0.304918 0.214796 41.797207 4.146920 57.898771 216.063740 3.695298 241.591743 5.000000 0.000000 5 
+-0.200000 1.000000 0.303232 0.212273 41.030377 3.715740 56.810498 214.633968 3.459259 236.183440 5.000000 0.000000 5 
+-0.100000 1.000000 0.298946 0.209960 40.968387 3.286066 56.947886 214.652174 3.930641 239.869339 5.000000 0.000000 5 
+0.000000 1.000000 0.294872 0.207036 40.536720 2.548956 56.696602 214.365610 3.293869 234.367863 5.000000 0.000000 5 
+0.100000 1.000000 0.288568 0.204592 40.484272 3.071800 57.461835 214.472268 3.512439 239.158665 5.000000 0.000000 5 
+0.200000 1.000000 0.282018 0.201547 40.681261 3.278471 55.951967 214.294295 3.840460 243.284465 5.000000 0.000000 5 
+0.300000 1.000000 0.279144 0.198894 40.435529 2.499194 56.196889 214.494088 4.754185 243.060995 5.000000 0.000000 5 
+0.400000 1.000000 0.272107 0.196146 40.439310 2.236700 56.900807 214.233221 2.429697 221.554971 5.000000 0.000000 5 
+0.500000 1.000000 0.264304 0.193699 40.079304 2.102994 56.885928 215.212068 2.867987 222.409413 5.000000 0.000000 5 
+0.600000 1.000000 0.254976 0.190952 40.938251 2.319068 57.553216 215.858396 3.257873 223.568005 5.000000 0.000000 5 
+0.700000 1.000000 0.249426 0.188038 41.563554 3.790154 57.245468 214.607164 2.598470 222.620303 5.000000 0.000000 5 
+0.800000 1.000000 0.236938 0.185676 40.644131 3.390736 56.250863 214.787514 3.016321 224.174840 5.000000 0.000000 5 
+0.900000 1.000000 0.224528 0.182548 41.177649 3.753531 57.657192 214.638930 3.869935 242.175272 5.000000 0.000000 5 
+1.000000 1.000000 0.212635 0.179447 41.573615 4.514914 56.159346 214.699737 3.876814 241.176210 5.000000 0.000000 5 
+1.100000 1.000000 0.201210 0.177071 41.261829 3.264320 56.243301 214.951544 2.847856 222.583377 5.000000 0.000000 5 
+1.200000 1.000000 0.183951 0.174506 41.683136 3.591689 56.992613 214.584652 3.373178 234.362666 5.000000 0.000000 5 
+1.300000 1.000000 0.173395 0.171834 40.814328 3.204918 56.758830 215.230164 3.553699 238.588538 5.000000 0.000000 5 
+1.400000 1.000000 0.152049 0.168623 41.412958 4.196153 57.855401 215.104553 3.855987 238.806435 5.000000 0.000000 5 
+1.500000 1.000000 0.137067 0.165760 40.865453 2.472355 57.692788 215.112473 2.817110 222.469712 5.000000 0.000000 5 
+1.600000 1.000000 0.119800 0.162857 41.340190 3.443653 56.853505 215.173558 2.871523 223.737602 5.000000 0.000000 5 
+1.700000 1.000000 0.105374 0.160314 41.913044 4.326664 61.356272 215.168234 3.325743 234.564531 5.000000 0.000000 5 
+1.800000 1.000000 0.089974 0.157458 40.750192 2.697542 57.266120 214.802052 3.061822 232.936883 5.000000 0.000000 5 
+1.900000 1.000000 0.077899 0.154930 40.986799 3.782287 56.577477 214.970573 3.337138 232.486819 5.000000 0.000000 5 
+2.000000 1.000000 0.064498 0.151912 40.973867 3.733968 57.266469 214.460835 4.009518 245.990164 5.000000 0.000000 5 
+2.100000 1.000000 0.055153 0.149119 41.501986 4.068195 58.938014 215.028530 4.322608 242.986899 5.000000 0.000000 5 
+2.200000 1.000000 0.043084 0.146548 40.912591 3.140756 56.434856 215.261084 2.631197 222.724293 5.000000 0.000000 5 
+2.300000 1.000000 0.032169 0.143665 40.804191 2.644521 55.770242 215.134604 4.499185 240.916434 5.000000 0.000000 5 
+2.400000 1.000000 0.025889 0.141218 41.065216 2.783687 57.783689 214.520582 3.945613 238.811603 5.000000 0.000000 5 
+2.500000 1.000000 0.019264 0.138524 41.211270 2.448662 57.622551 214.922236 2.973268 230.669525 5.000000 0.000000 5 
+2.600000 1.000000 0.013900 0.135256 40.354411 2.250096 55.698937 214.996483 3.189890 234.888937 5.000000 0.000000 5 
+2.700000 1.000000 0.009590 0.132552 41.244662 3.881499 56.758825 214.759792 3.247172 234.516795 5.000000 0.000000 5 
+2.800000 1.000000 0.006381 0.129862 41.636845 4.629420 56.879917 215.118519 4.535658 246.588967 5.000000 0.000000 5 
+2.900000 1.000000 0.004505 0.127161 41.056717 3.728615 56.343533 215.634561 3.446083 235.626106 5.000000 0.000000 5 
+3.000000 1.000000 0.003107 0.124625 41.763560 4.761839 62.852163 214.987054 4.100187 244.479813 5.000000 0.000000 5 
+3.100000 1.000000 0.001585 0.121596 41.488940 3.655265 56.817517 215.049416 3.036645 231.524449 5.000000 0.000000 5 
+3.200000 0.990000 0.000884 0.119036 41.899580 4.667199 62.415123 215.081178 3.177671 232.511648 5.000000 0.000000 5 
+3.300000 0.980000 0.000665 0.116153 41.752611 3.754668 57.178144 215.574362 3.084230 229.518521 5.000000 0.000000 5 
+3.400000 0.790000 0.000277 0.113482 41.601818 3.333514 55.861571 215.582128 3.219449 226.902719 5.000000 0.000000 5 
+3.500000 0.700000 0.000179 0.111022 42.147840 4.133196 57.255484 215.854669 3.893844 242.048395 5.000000 0.000000 5 
+3.600000 0.410000 0.000069 0.108080 40.747050 3.759419 63.745698 215.804914 2.568863 222.540313 5.000000 0.000000 5 
+3.700000 0.370000 0.000060 0.105610 41.386558 3.815417 56.528228 215.889033 2.973628 224.110377 5.000000 0.000000 5 
+3.800000 0.130000 0.000019 0.103046 41.389957 3.987060 57.528132 216.368785 3.604357 233.239650 5.000000 0.000000 5 
+3.900000 0.110000 0.000013 0.100373 41.026006 2.726123 56.144907 216.842031 4.984859 241.533824 5.000000 0.000000 5 
+4.000000 0.040000 0.000005 0.097515 41.535921 3.298320 56.226860 216.230174 3.561244 238.655176 5.000000 0.000000 5 
+4.100000 0.020000 0.000002 0.095597 41.107849 2.874834 55.301615 216.417801 3.911892 236.928735 5.000000 0.000000 5 
+4.200000 0.010000 0.000001 0.091987 40.473716 2.580630 55.248263 216.739394 4.297853 245.792709 5.000000 0.000000 5 
+4.300000 0.000000 0.000000 0.090448 40.613263 2.726066 56.542856 217.487654 4.100344 239.897164 5.000000 0.000000 5 
diff --git a/cmake_targets/ldpctest_BG_1_Zc_384_rate_2-3_block_length_8448_maxit_5.txt b/cmake_targets/ldpctest_BG_1_Zc_384_rate_2-3_block_length_8448_maxit_5.txt
deleted file mode 100644
index a52340ec27..0000000000
--- a/cmake_targets/ldpctest_BG_1_Zc_384_rate_2-3_block_length_8448_maxit_5.txt
+++ /dev/null
@@ -1,72 +0,0 @@
-SNR BLER BER UNCODED_BER ENCODER_MEAN ENCODER_STD ENCODER_MAX DECODER_TIME_MEAN DECODER_TIME_STD DECODER_TIME_MAX DECODER_ITER_MEAN DECODER_ITER_STD DECODER_ITER_MAX
--2.000000 1.000000 0.207386 0.181660 350.462328 0.000002 350.462328 163.684321 -nan 163.684321 5.000000 0.000000 5 
--1.900000 1.000000 0.203362 0.181424 49.691355 0.000000 49.691355 106.612229 -nan 106.612229 5.000000 0.000000 5 
--1.800000 1.000000 0.203243 0.174874 41.156574 0.000001 41.156574 106.419533 0.000001 106.419533 5.000000 0.000000 5 
--1.700000 1.000000 0.199692 0.176373 41.576557 0.000000 41.576557 106.249571 0.000001 106.249571 5.000000 0.000000 5 
--1.600000 1.000000 0.191525 0.162247 41.056596 -nan 41.056596 105.518964 0.000001 105.518964 5.000000 0.000000 5 
--1.500000 1.000000 0.193774 0.164378 41.485219 -nan 41.485219 106.890835 0.000001 106.890835 5.000000 0.000000 5 
--1.400000 1.000000 0.192235 0.164852 41.377230 0.000000 41.377230 106.884179 0.000002 106.884179 5.000000 0.000000 5 
--1.300000 1.000000 0.189157 0.157434 41.882535 -nan 41.882535 118.201437 0.000001 118.201437 5.000000 0.000000 5 
--1.200000 1.000000 0.189394 0.156487 40.273742 0.000000 40.273742 108.077486 0.000001 108.077486 5.000000 0.000000 5 
--1.100000 1.000000 0.180279 0.151042 41.475883 0.000000 41.475883 105.804899 0.000002 105.804899 5.000000 0.000000 5 
--1.000000 1.000000 0.185133 0.150016 41.863188 -nan 41.863188 105.778227 -nan 105.778227 5.000000 0.000000 5 
--0.900000 1.000000 0.180043 0.148280 41.788530 -nan 41.788530 106.533519 -nan 106.533519 5.000000 0.000000 5 
--0.800000 1.000000 0.181700 0.148990 41.606549 -nan 41.606549 122.353146 -nan 122.353146 5.000000 0.000000 5 
--0.700000 1.000000 0.176136 0.143071 40.958788 0.000001 40.958788 107.100677 0.000001 107.100677 5.000000 0.000000 5 
--0.600000 1.000000 0.173414 0.142124 40.818434 -nan 40.818434 114.571862 0.000001 114.571862 5.000000 0.000000 5 
--0.500000 1.000000 0.169744 0.136758 41.645212 -nan 41.645212 106.311549 -nan 106.311549 5.000000 0.000000 5 
--0.400000 1.000000 0.170928 0.134549 42.533159 0.000000 42.533159 106.571549 0.000002 106.571549 5.000000 0.000000 5 
--0.300000 1.000000 0.166312 0.131629 42.162494 -nan 42.162494 106.150186 0.000001 106.150186 5.000000 0.000000 5 
--0.200000 1.000000 0.163116 0.134549 41.555882 -nan 41.555882 105.973565 -nan 105.973565 5.000000 0.000000 5 
--0.100000 1.000000 0.165009 0.127525 41.716528 0.000000 41.716528 117.108125 -nan 117.108125 5.000000 0.000000 5 
-0.000000 1.000000 0.153646 0.125868 42.135839 0.000001 42.135839 106.297533 0.000001 106.297533 5.000000 0.000000 5 
-0.100000 1.000000 0.149503 0.116319 41.863859 0.000001 41.863859 105.946896 -nan 105.946896 5.000000 0.000000 5 
-0.200000 1.000000 0.151160 0.116162 41.518563 0.000000 41.518563 106.233579 0.000001 106.233579 5.000000 0.000000 5 
-0.300000 1.000000 0.151752 0.114899 108.694179 -nan 108.694179 116.888156 -nan 116.888156 5.000000 0.000000 5 
-0.400000 1.000000 0.148319 0.114268 76.352135 -nan 76.352135 107.328026 0.000002 107.328026 5.000000 0.000000 5 
-0.500000 1.000000 0.143229 0.108823 56.976621 -nan 56.976621 106.411111 0.000002 106.411111 5.000000 0.000000 5 
-0.600000 1.000000 0.140152 0.105429 43.605068 -nan 43.605068 129.179314 -nan 129.179314 5.000000 0.000000 5 
-0.700000 1.000000 0.142401 0.108665 42.849130 -nan 42.849130 106.146889 0.000002 106.146889 5.000000 0.000000 5 
-0.800000 1.000000 0.134115 0.102983 41.805179 -nan 41.805179 105.963518 0.000001 105.963518 5.000000 0.000000 5 
-0.900000 1.000000 0.142164 0.105193 41.508383 -nan 41.508383 105.615827 -nan 105.615827 5.000000 0.000000 5 
-1.000000 1.000000 0.131392 0.095802 41.079894 -nan 41.079894 106.092172 0.000001 106.092172 5.000000 0.000000 5 
-1.100000 1.000000 0.133404 0.095565 41.256573 -nan 41.256573 106.134900 0.000001 106.134900 5.000000 0.000000 5 
-1.200000 1.000000 0.131984 0.093277 41.155656 0.000001 41.155656 105.820640 0.000001 105.820640 5.000000 0.000000 5 
-1.300000 1.000000 0.125473 0.089883 40.216642 -nan 40.216642 105.099633 -nan 105.099633 5.000000 0.000000 5 
-1.400000 1.000000 0.115649 0.083333 52.048960 0.000000 52.048960 106.145774 -nan 106.145774 5.000000 0.000000 5 
-1.500000 1.000000 0.128433 0.083807 40.463956 -nan 40.463956 105.743583 -nan 105.743583 5.000000 0.000000 5 
-1.600000 1.000000 0.122869 0.082071 41.049216 0.000001 41.049216 105.206197 0.000001 105.206197 5.000000 0.000000 5 
-1.700000 1.000000 0.122988 0.080492 41.913872 -nan 41.913872 104.823010 -nan 104.823010 5.000000 0.000000 5 
-1.800000 1.000000 0.117898 0.078362 40.812444 0.000000 40.812444 105.950499 -nan 105.950499 5.000000 0.000000 5 
-1.900000 1.000000 0.117069 0.078598 41.428562 0.000000 41.428562 105.008310 0.000002 105.008310 5.000000 0.000000 5 
-2.000000 1.000000 0.109730 0.070865 40.903956 -nan 40.903956 106.049516 -nan 106.049516 5.000000 0.000000 5 
-2.100000 1.000000 0.110677 0.071496 40.365980 0.000000 40.365980 105.550308 -nan 105.550308 5.000000 0.000000 5 
-2.200000 1.000000 0.106061 0.066840 40.098505 0.000001 40.098505 116.386458 -nan 116.386458 5.000000 0.000000 5 
-2.300000 1.000000 0.107836 0.066840 41.630557 -nan 41.630557 105.830275 0.000001 105.830275 5.000000 0.000000 5 
-2.400000 1.000000 0.099313 0.063131 40.906595 0.000000 40.906595 105.513603 0.000001 105.513603 5.000000 0.000000 5 
-2.500000 1.000000 0.100734 0.061711 41.383906 0.000001 41.383906 106.573557 -nan 106.573557 5.000000 0.000000 5 
-2.600000 1.000000 0.096828 0.056108 41.539890 -nan 41.539890 105.375623 -nan 105.375623 5.000000 0.000000 5 
-2.700000 1.000000 0.097301 0.059975 40.686462 0.000000 40.686462 106.816461 0.000001 106.816461 5.000000 0.000000 5 
-2.800000 1.000000 0.094342 0.055319 40.302460 0.000001 40.302460 106.105103 -nan 106.105103 5.000000 0.000000 5 
-2.900000 1.000000 0.096946 0.053977 40.671276 -nan 40.671276 105.606260 -nan 105.606260 5.000000 0.000000 5 
-3.000000 1.000000 0.086529 0.050821 41.382575 -nan 41.382575 106.268916 0.000001 106.268916 5.000000 0.000000 5 
-3.100000 1.000000 0.088068 0.046796 40.087170 0.000001 40.087170 106.017849 -nan 106.017849 5.000000 0.000000 5 
-3.200000 1.000000 0.088778 0.048690 41.208411 -nan 41.208411 106.485115 -nan 106.485115 5.000000 0.000000 5 
-3.300000 1.000000 0.088660 0.045376 46.839523 0.000000 46.839523 105.171609 -nan 105.171609 5.000000 0.000000 5 
-3.400000 1.000000 0.086056 0.043876 41.234103 0.000000 41.234103 105.971413 -nan 105.971413 5.000000 0.000000 5 
-3.500000 1.000000 0.085346 0.044271 51.914538 0.000000 51.914538 105.250315 -nan 105.250315 5.000000 0.000000 5 
-3.600000 1.000000 0.080611 0.039615 39.788348 0.000000 39.788348 105.681404 0.000001 105.681404 5.000000 0.000000 5 
-3.700000 1.000000 0.081676 0.037405 41.516546 -nan 41.516546 106.541514 -nan 106.541514 5.000000 0.000000 5 
-3.800000 1.000000 0.082623 0.038826 41.013898 -nan 41.013898 105.181567 0.000002 105.181567 5.000000 0.000000 5 
-3.900000 1.000000 0.077770 0.034564 40.907250 -nan 40.907250 105.474242 -nan 105.474242 5.000000 0.000000 5 
-4.000000 1.000000 0.075166 0.032434 40.525805 -nan 40.525805 106.856454 -nan 106.856454 5.000000 0.000000 5 
-4.100000 1.000000 0.073745 0.030619 41.863868 0.000001 41.863868 104.952984 -nan 104.952984 5.000000 0.000000 5 
-4.200000 1.000000 0.072206 0.028093 40.012507 0.000000 40.012507 105.829858 0.000001 105.829858 5.000000 0.000000 5 
-4.300000 1.000000 0.073509 0.029040 41.265241 -nan 41.265241 106.866855 -nan 106.866855 5.000000 0.000000 5 
-4.400000 1.000000 0.070312 0.028251 42.004048 -nan 42.004048 104.724794 -nan 104.724794 5.000000 0.000000 5 
-4.500000 1.000000 0.071023 0.026515 40.553139 -nan 40.553139 106.168510 -nan 106.168510 5.000000 0.000000 5 
-4.600000 1.000000 0.070076 0.025016 41.453892 -nan 41.453892 105.339616 -nan 105.339616 5.000000 0.000000 5 
-4.700000 1.000000 0.064631 0.023438 42.209825 0.000000 42.209825 105.972866 -nan 105.972866 5.000000 0.000000 5 
-4.800000 1.000000 0.063920 0.022727 41.778528 0.000001 41.778528 106.402189 0.000001 106.402189 5.000000 0.000000 5 
-4.900000 1.000000 0.063447 0.018782 40.201824 0.000001 40.201824 106.177825 0.000001 106.177825 5.000000 0.000000 5 
-5.000000 1.000000 0.056937 0.017677 42.106087 -nan 42.106087 106.188160 0.000000 106.188160 5.000000 0.00000
\ No newline at end of file
diff --git a/cmake_targets/ldpctest_BG_2_Zc_2_rate_1-3_block_length_-27056_maxit_5.txt b/cmake_targets/ldpctest_BG_2_Zc_2_rate_1-3_block_length_-27056_maxit_5.txt
deleted file mode 100644
index e69de29bb2..0000000000
diff --git a/cmake_targets/ldpctest_BG_2_Zc_320_rate_1-3_block_length_3200_maxit_5.txt b/cmake_targets/ldpctest_BG_2_Zc_320_rate_1-3_block_length_3200_maxit_5.txt
deleted file mode 100644
index e69de29bb2..0000000000
diff --git a/cmake_targets/ldpctest_BG_2_Zc_384_rate_1-3_block_length_3840_maxit_5.txt b/cmake_targets/ldpctest_BG_2_Zc_384_rate_1-3_block_length_3840_maxit_5.txt
deleted file mode 100644
index e69de29bb2..0000000000
diff --git a/cmake_targets/ldpctest_BG_2_Zc_3_rate_1-3_block_length_16_maxit_5.txt b/cmake_targets/ldpctest_BG_2_Zc_3_rate_1-3_block_length_16_maxit_5.txt
deleted file mode 100644
index 6eea8e3e0e..0000000000
--- a/cmake_targets/ldpctest_BG_2_Zc_3_rate_1-3_block_length_16_maxit_5.txt
+++ /dev/null
@@ -1,152 +0,0 @@
-SNR BLER BER UNCODED_BER ENCODER_MEAN ENCODER_STD ENCODER_MAX DECODER_TIME_MEAN DECODER_TIME_STD DECODER_TIME_MAX DECODER_ITER_MEAN DECODER_ITER_STD DECODER_ITER_MAX
--2.000000 1.000000 0.562500 0.320000 16.558900 -nan 16.558900 98.248806 -nan 98.248806 5.000000 0.000000 5 
--1.900000 1.000000 0.625000 0.280000 5.056975 0.000000 5.056975 31.887740 0.000000 31.887740 5.000000 0.000000 5 
--1.800000 1.000000 0.187500 0.140000 4.418373 -nan 4.418373 29.037403 0.000000 29.037403 5.000000 0.000000 5 
--1.700000 1.000000 0.437500 0.240000 4.722354 0.000000 4.722354 29.116069 -nan 29.116069 5.000000 0.000000 5 
--1.600000 1.000000 0.125000 0.120000 4.569696 0.000000 4.569696 28.901412 0.000000 28.901412 5.000000 0.000000 5 
--1.500000 1.000000 0.500000 0.280000 4.363693 -nan 4.363693 29.902562 -nan 29.902562 5.000000 0.000000 5 
--1.400000 1.000000 0.437500 0.280000 4.397709 -nan 4.397709 29.485381 -nan 29.485381 5.000000 0.000000 5 
--1.300000 1.000000 0.500000 0.280000 4.290382 -nan 4.290382 28.529440 0.000000 28.529440 5.000000 0.000000 5 
--1.200000 1.000000 0.437500 0.340000 3.894409 0.000000 3.894409 28.447450 -nan 28.447450 5.000000 0.000000 5 
--1.100000 1.000000 0.375000 0.200000 4.344376 0.000000 4.344376 28.357438 -nan 28.357438 5.000000 0.000000 5 
--1.000000 1.000000 0.187500 0.220000 3.817747 0.000000 3.817747 33.455113 -nan 33.455113 5.000000 0.000000 5 
--0.900000 1.000000 0.250000 0.280000 4.368376 0.000000 4.368376 28.184126 -nan 28.184126 5.000000 0.000000 5 
--0.800000 1.000000 0.437500 0.160000 4.477704 0.000000 4.477704 28.686771 -nan 28.686771 5.000000 0.000000 5 
--0.700000 1.000000 0.437500 0.300000 4.355712 -nan 4.355712 28.232797 0.000001 28.232797 5.000000 0.000000 5 
--0.600000 1.000000 0.375000 0.240000 4.262384 -nan 4.262384 34.447051 0.000000 34.447051 5.000000 0.000000 5 
--0.500000 1.000000 0.375000 0.120000 4.539718 0.000000 4.539718 29.700155 0.000000 29.700155 5.000000 0.000000 5 
--0.400000 1.000000 0.375000 0.220000 4.539030 0.000000 4.539030 28.796743 -nan 28.796743 5.000000 0.000000 5 
--0.300000 1.000000 0.375000 0.140000 4.653669 0.000000 4.653669 30.096528 -nan 30.096528 5.000000 0.000000 5 
--0.200000 1.000000 0.250000 0.180000 4.250385 -nan 4.250385 28.218130 0.000000 28.218130 5.000000 0.000000 5 
--0.100000 1.000000 0.437500 0.180000 4.543033 0.000000 4.543033 28.602773 0.000000 28.602773 5.000000 0.000000 5 
-0.000000 1.000000 0.500000 0.260000 4.252385 -nan 4.252385 27.672170 -nan 27.672170 5.000000 0.000000 5 
-0.100000 1.000000 0.250000 0.140000 4.244451 0.000000 4.244451 27.672594 -nan 27.672594 5.000000 0.000000 5 
-0.200000 1.000000 0.437500 0.100000 4.452372 -nan 4.452372 28.569440 0.000000 28.569440 5.000000 0.000000 5 
-0.300000 1.000000 0.375000 0.160000 4.005736 -nan 4.005736 27.550850 0.000000 27.550850 5.000000 0.000000 5 
-0.400000 1.000000 0.375000 0.080000 4.235055 0.000000 4.235055 28.246812 0.000000 28.246812 5.000000 0.000000 5 
-0.500000 1.000000 0.375000 0.240000 4.916981 -nan 4.916981 31.409083 0.000000 31.409083 5.000000 0.000000 5 
-0.600000 1.000000 0.437500 0.160000 4.461020 -nan 4.461020 30.399862 -nan 30.399862 5.000000 0.000000 5 
-0.700000 1.000000 0.125000 0.100000 4.344377 -nan 4.344377 29.007399 -nan 29.007399 5.000000 0.000000 5 
-0.800000 1.000000 0.312500 0.380000 4.237720 0.000000 4.237720 28.431454 -nan 28.431454 5.000000 0.000000 5 
-0.900000 1.000000 0.250000 0.160000 4.176390 0.000000 4.176390 28.552107 -nan 28.552107 5.000000 0.000000 5 
-1.000000 1.000000 0.187500 0.100000 4.611028 0.000000 4.611028 27.871487 -nan 27.871487 5.000000 0.000000 5 
-1.100000 1.000000 0.375000 0.180000 4.480371 -nan 4.480371 27.896158 -nan 27.896158 5.000000 0.000000 5 
-1.200000 1.000000 0.250000 0.120000 4.134394 0.000000 4.134394 27.622178 0.000000 27.622178 5.000000 0.000000 5 
-1.300000 1.000000 0.437500 0.200000 4.323715 0.000000 4.323715 28.078815 -nan 28.078815 5.000000 0.000000 5 
-1.400000 1.000000 0.312500 0.140000 4.280365 -nan 4.280365 29.175942 -nan 29.175942 5.000000 0.000000 5 
-1.500000 1.000000 0.312500 0.140000 4.494351 -nan 4.494351 32.561044 -nan 32.561044 5.000000 0.000000 5 
-1.600000 1.000000 0.125000 0.100000 4.466369 0.000000 4.466369 30.673292 -nan 30.673292 5.000000 0.000000 5 
-1.700000 1.000000 0.187500 0.180000 4.412375 0.000000 4.412375 30.016683 0.000000 30.016683 5.000000 0.000000 5 
-1.800000 1.000000 0.250000 0.160000 4.627027 -nan 4.627027 29.532714 -nan 29.532714 5.000000 0.000000 5 
-1.900000 1.000000 0.187500 0.100000 4.265051 0.000000 4.265051 29.390721 -nan 29.390721 5.000000 0.000000 5 
-2.000000 1.000000 0.312500 0.200000 4.609676 -nan 4.609676 30.795835 0.000000 30.795835 5.000000 0.000000 5 
-2.100000 1.000000 0.250000 0.180000 4.649025 -nan 4.649025 28.821421 0.000000 28.821421 5.000000 0.000000 5 
-2.200000 1.000000 0.062500 0.160000 4.745018 0.000000 4.745018 29.222057 0.000000 29.222057 5.000000 0.000000 5 
-2.300000 1.000000 0.250000 0.120000 4.333046 -nan 4.333046 28.623435 -nan 28.623435 5.000000 0.000000 5 
-2.400000 1.000000 0.187500 0.120000 4.795017 0.000000 4.795017 28.746101 -nan 28.746101 5.000000 0.000000 5 
-2.500000 1.000000 0.562500 0.180000 4.248368 -nan 4.248368 30.448523 -nan 30.448523 5.000000 0.000000 5 
-2.600000 1.000000 0.062500 0.140000 4.312380 -nan 4.312380 29.250725 -nan 29.250725 5.000000 0.000000 5 
-2.700000 1.000000 0.375000 0.140000 4.319714 0.000000 4.319714 28.350787 -nan 28.350787 5.000000 0.000000 5 
-2.800000 1.000000 0.312500 0.120000 4.172389 0.000000 4.172389 29.005404 -nan 29.005404 5.000000 0.000000 5 
-2.900000 1.000000 0.250000 0.120000 4.944978 0.000000 4.944978 33.555592 -nan 33.555592 5.000000 0.000000 5 
-3.000000 1.000000 0.437500 0.180000 4.529031 -nan 4.529031 29.354708 -nan 29.354708 5.000000 0.000000 5 
-3.100000 1.000000 0.125000 0.140000 4.411728 -nan 4.411728 29.312859 -nan 29.312859 5.000000 0.000000 5 
-3.200000 1.000000 0.250000 0.180000 4.059064 0.000000 4.059064 28.636770 0.000000 28.636770 5.000000 0.000000 5 
-3.300000 1.000000 0.500000 0.120000 3.996402 0.000000 3.996402 28.211468 0.000000 28.211468 5.000000 0.000000 5 
-3.400000 1.000000 0.125000 0.040000 4.909645 0.000000 4.909645 31.661710 -nan 31.661710 5.000000 0.000000 5 
-3.500000 1.000000 0.375000 0.140000 4.603009 -nan 4.603009 30.342529 -nan 30.342529 5.000000 0.000000 5 
-3.600000 1.000000 0.500000 0.040000 4.709684 -nan 4.709684 29.388030 0.000000 29.388030 5.000000 0.000000 5 
-3.700000 1.000000 0.312500 0.080000 4.393042 0.000000 4.393042 28.605437 -nan 28.605437 5.000000 0.000000 5 
-3.800000 1.000000 0.250000 0.120000 4.591689 0.000000 4.591689 29.398009 -nan 29.398009 5.000000 0.000000 5 
-3.900000 1.000000 0.312500 0.080000 4.534365 0.000000 4.534365 28.915407 0.000000 28.915407 5.000000 0.000000 5 
-4.000000 1.000000 0.125000 0.060000 4.476369 -nan 4.476369 28.420780 0.000000 28.420780 5.000000 0.000000 5 
-4.100000 1.000000 0.250000 0.100000 4.396375 -nan 4.396375 27.914146 -nan 27.914146 5.000000 0.000000 5 
-4.200000 1.000000 0.312500 0.080000 4.414355 -nan 4.414355 30.324526 -nan 30.324526 5.000000 0.000000 5 
-4.300000 1.000000 0.187500 0.100000 4.094394 -nan 4.094394 29.670022 -nan 29.670022 5.000000 0.000000 5 
-4.400000 1.000000 0.125000 0.100000 4.547800 0.000000 4.547800 28.900730 0.000000 28.900730 5.000000 0.000000 5 
-4.500000 1.000000 0.250000 0.120000 4.229703 0.000000 4.229703 30.204544 -nan 30.204544 5.000000 0.000000 5 
-4.600000 1.000000 0.375000 0.100000 4.371042 0.000000 4.371042 29.030068 0.000000 29.030068 5.000000 0.000000 5 
-4.700000 1.000000 0.187500 0.060000 4.054398 -nan 4.054398 28.180132 -nan 28.180132 5.000000 0.000000 5 
-4.800000 1.000000 0.437500 0.140000 5.543598 -nan 5.543598 33.959538 0.000000 33.959538 5.000000 0.000000 5 
-4.900000 1.000000 0.187500 0.040000 4.659582 -nan 4.659582 30.629255 -nan 30.629255 5.000000 0.000000 5 
-5.000000 1.000000 0.375000 0.020000 4.568363 0.000000 4.568363 29.642031 0.000000 29.642031 5.000000 0.000000 5 
-5.100000 1.000000 0.250000 0.080000 4.759018 0.000000 4.759018 28.678100 -nan 28.678100 5.000000 0.000000 5 
-5.200000 1.000000 0.187500 0.080000 4.454367 0.000000 4.454367 27.988120 0.000000 27.988120 5.000000 0.000000 5 
-5.300000 1.000000 0.312500 0.080000 4.436372 0.000000 4.436372 28.547440 0.000000 28.547440 5.000000 0.000000 5 
-5.400000 1.000000 0.125000 0.020000 4.363711 0.000000 4.363711 28.698766 -nan 28.698766 5.000000 0.000000 5 
-5.500000 1.000000 0.187500 0.080000 4.438354 -nan 4.438354 30.491853 -nan 30.491853 5.000000 0.000000 5 
-5.600000 1.000000 0.500000 0.060000 4.406355 0.000000 4.406355 30.280521 0.000000 30.280521 5.000000 0.000000 5 
-5.700000 1.000000 0.250000 0.100000 4.377042 -nan 4.377042 28.816746 -nan 28.816746 5.000000 0.000000 5 
-5.800000 1.000000 0.250000 0.100000 4.125727 0.000000 4.125727 28.794764 -nan 28.794764 5.000000 0.000000 5 
-5.900000 1.000000 0.062500 0.040000 4.412373 -nan 4.412373 28.877411 -nan 28.877411 5.000000 0.000000 5 
-6.000000 1.000000 0.187500 0.000000 4.297716 0.000000 4.297716 28.497449 -nan 28.497449 5.000000 0.000000 5 
-6.100000 1.000000 0.312500 0.040000 4.266383 -nan 4.266383 28.602762 0.000000 28.602762 5.000000 0.000000 5 
-6.200000 1.000000 0.312500 0.080000 4.351711 0.000000 4.351711 28.211460 -nan 28.211460 5.000000 0.000000 5 
-6.300000 1.000000 0.312500 0.040000 4.279052 0.000000 4.279052 28.560120 -nan 28.560120 5.000000 0.000000 5 
-6.400000 1.000000 0.375000 0.020000 4.355713 0.000000 4.355713 28.658110 -nan 28.658110 5.000000 0.000000 5 
-6.500000 1.000000 0.312500 0.060000 4.288363 0.000000 4.288363 30.102535 0.000000 30.102535 5.000000 0.000000 5 
-6.600000 1.000000 0.312500 0.020000 4.607677 0.000000 4.607677 30.151217 -nan 30.151217 5.000000 0.000000 5 
-6.700000 1.000000 0.187500 0.000000 4.256384 0.000000 4.256384 28.896748 0.000000 28.896748 5.000000 0.000000 5 
-6.800000 1.000000 0.187500 0.020000 4.527034 -nan 4.527034 28.631442 -nan 28.631442 5.000000 0.000000 5 
-6.900000 1.000000 0.187500 0.020000 4.629029 0.000000 4.629029 29.180745 0.000000 29.180745 5.000000 0.000000 5 
-7.000000 1.000000 0.375000 0.040000 4.590361 0.000000 4.590361 28.382779 0.000000 28.382779 5.000000 0.000000 5 
-7.100000 1.000000 0.312500 0.020000 4.435038 0.000000 4.435038 28.220122 0.000000 28.220122 5.000000 0.000000 5 
-7.200000 1.000000 0.250000 0.020000 4.383044 0.000000 4.383044 28.424793 -nan 28.424793 5.000000 0.000000 5 
-7.300000 1.000000 0.250000 0.040000 4.101730 0.000000 4.101730 28.118147 0.000000 28.118147 5.000000 0.000000 5 
-7.400000 1.000000 0.125000 0.040000 3.970402 0.000000 3.970402 28.219456 -nan 28.219456 5.000000 0.000000 5 
-7.500000 1.000000 0.375000 0.040000 4.549015 -nan 4.549015 30.481869 0.000000 30.481869 5.000000 0.000000 5 
-7.600000 1.000000 0.312500 0.020000 4.665690 0.000000 4.665690 28.734088 0.000000 28.734088 5.000000 0.000000 5 
-7.700000 1.000000 0.187500 0.020000 4.490370 0.000000 4.490370 28.008148 0.000000 28.008148 5.000000 0.000000 5 
-7.800000 1.000000 0.250000 0.020000 9.884010 0.000000 9.884010 28.440778 -nan 28.440778 5.000000 0.000000 5 
-7.900000 1.000000 0.187500 0.040000 4.277716 0.000000 4.277716 28.763425 -nan 28.763425 5.000000 0.000000 5 
-8.000000 1.000000 0.125000 0.020000 4.447036 -nan 4.447036 28.524094 -nan 28.524094 5.000000 0.000000 5 
-8.100000 1.000000 0.250000 0.000000 4.479672 0.000000 4.479672 28.772560 0.000000 28.772560 5.000000 0.000000 5 
-8.200000 1.000000 0.187500 0.020000 4.383042 -nan 4.383042 28.702093 0.000000 28.702093 5.000000 0.000000 5 
-8.300000 1.000000 0.250000 0.000000 4.289049 -nan 4.289049 28.742097 -nan 28.742097 5.000000 0.000000 5 
-8.400000 1.000000 0.250000 0.020000 4.756349 0.000000 4.756349 30.240650 -nan 30.240650 5.000000 0.000000 5 
-8.500000 1.000000 0.250000 0.020000 4.663671 -nan 4.663671 30.713836 -nan 30.713836 5.000000 0.000000 5 
-8.600000 1.000000 0.312500 0.020000 4.732378 -nan 4.732378 29.348876 -nan 29.348876 5.000000 0.000000 5 
-8.700000 1.000000 0.250000 0.020000 4.403710 -nan 4.403710 28.150814 -nan 28.150814 5.000000 0.000000 5 
-8.800000 1.000000 0.250000 0.020000 4.612360 0.000000 4.612360 29.196726 -nan 29.196726 5.000000 0.000000 5 
-8.900000 1.000000 0.187500 0.020000 4.459038 0.000000 4.459038 28.099474 -nan 28.099474 5.000000 0.000000 5 
-9.000000 1.000000 0.187500 0.020000 4.453704 0.000000 4.453704 28.049467 0.000000 28.049467 5.000000 0.000000 5 
-9.100000 1.000000 0.250000 0.020000 4.443039 -nan 4.443039 27.916816 -nan 27.916816 5.000000 0.000000 5 
-9.200000 1.000000 0.187500 0.000000 4.434350 0.000000 4.434350 28.470635 -nan 28.470635 5.000000 0.000000 5 
-9.300000 1.000000 0.312500 0.000000 4.105062 -nan 4.105062 28.216799 -nan 28.216799 5.000000 0.000000 5 
-9.400000 1.000000 0.250000 0.040000 5.181005 -nan 5.181005 31.605329 -nan 31.605329 5.000000 0.000000 5 
-9.500000 1.000000 0.375000 0.000000 4.506347 0.000000 4.506347 30.239857 0.000000 30.239857 5.000000 0.000000 5 
-9.600000 1.000000 0.250000 0.000000 4.637024 0.000000 4.637024 29.628692 0.000000 29.628692 5.000000 0.000000 5 
-9.700000 1.000000 0.312500 0.000000 4.357045 -nan 4.357045 28.601440 -nan 28.601440 5.000000 0.000000 5 
-9.800000 1.000000 0.250000 0.000000 4.279715 0.000000 4.279715 28.856745 0.000000 28.856745 5.000000 0.000000 5 
-9.900000 1.000000 0.187500 0.020000 4.336378 0.000000 4.336378 28.377448 -nan 28.377448 5.000000 0.000000 5 
-10.000000 1.000000 0.187500 0.020000 4.402374 0.000000 4.402374 29.169393 0.000000 29.169393 5.000000 0.000000 5 
-10.100000 1.000000 0.437500 0.000000 4.843655 -nan 4.843655 30.677815 -nan 30.677815 5.000000 0.000000 5 
-10.200000 1.000000 0.250000 0.000000 4.413211 -nan 4.413211 29.032526 0.000000 29.032526 5.000000 0.000000 5 
-10.300000 1.000000 0.312500 0.000000 4.211722 0.000000 4.211722 28.791430 0.000000 28.791430 5.000000 0.000000 5 
-10.400000 1.000000 0.312500 0.000000 4.439064 -nan 4.439064 28.281621 0.000000 28.281621 5.000000 0.000000 5 
-10.500000 1.000000 0.500000 0.040000 4.121710 0.000000 4.121710 30.037887 0.000000 30.037887 5.000000 0.000000 5 
-10.600000 1.000000 0.250000 0.000000 4.272383 -nan 4.272383 28.627431 -nan 28.627431 5.000000 0.000000 5 
-10.700000 1.000000 0.312500 0.000000 4.491702 -nan 4.491702 28.356121 0.000000 28.356121 5.000000 0.000000 5 
-10.800000 1.000000 0.187500 0.000000 4.392376 -nan 4.392376 28.664106 -nan 28.664106 5.000000 0.000000 5 
-10.900000 1.000000 0.375000 0.000000 3.967071 -nan 3.967071 28.541443 0.000000 28.541443 5.000000 0.000000 5 
-11.000000 1.000000 0.375000 0.000000 4.294383 -nan 4.294383 28.594777 -nan 28.594777 5.000000 0.000000 5 
-11.100000 1.000000 0.437500 0.000000 4.164392 0.000000 4.164392 28.584779 -nan 28.584779 5.000000 0.000000 5 
-11.200000 1.000000 0.125000 0.000000 4.315715 -nan 4.315715 27.770169 0.000000 27.770169 5.000000 0.000000 5 
-11.300000 1.000000 0.312500 0.020000 4.376377 -nan 4.376377 28.887422 -nan 28.887422 5.000000 0.000000 5 
-11.400000 1.000000 0.312500 0.000000 4.140392 0.000000 4.140392 28.411447 0.000000 28.411447 5.000000 0.000000 5 
-11.500000 1.000000 0.250000 0.000000 4.601009 0.000000 4.601009 30.469187 0.000000 30.469187 5.000000 0.000000 5 
-11.600000 1.000000 0.312500 0.000000 4.681749 0.000000 4.681749 28.638466 -nan 28.638466 5.000000 0.000000 5 
-11.700000 1.000000 0.375000 0.000000 4.464371 -nan 4.464371 28.934085 -nan 28.934085 5.000000 0.000000 5 
-11.800000 1.000000 0.250000 0.000000 4.650340 0.000000 4.650340 29.455266 -nan 29.455266 5.000000 0.000000 5 
-11.900000 1.000000 0.312500 0.000000 4.301714 -nan 4.301714 29.464708 -nan 29.464708 5.000000 0.000000 5 
-12.000000 1.000000 0.187500 0.000000 4.185721 0.000000 4.185721 28.613426 -nan 28.613426 5.000000 0.000000 5 
-12.100000 1.000000 0.187500 0.000000 4.157056 -nan 4.157056 28.573427 -nan 28.573427 5.000000 0.000000 5 
-12.200000 1.000000 0.312500 0.000000 4.522367 -nan 4.522367 48.212142 0.000001 48.212142 5.000000 0.000000 5 
-12.300000 1.000000 0.375000 0.000000 4.847011 0.000000 4.847011 54.012409 0.000000 54.012409 5.000000 0.000000 5 
-12.400000 1.000000 0.250000 0.000000 4.805679 -nan 4.805679 43.009793 0.000000 43.009793 5.000000 0.000000 5 
-12.500000 1.000000 0.187500 0.000000 4.715667 0.000000 4.715667 30.502515 0.000000 30.502515 5.000000 0.000000 5 
-12.600000 1.000000 0.250000 0.000000 4.708327 0.000000 4.708327 31.805709 -nan 31.805709 5.000000 0.000000 5 
-12.700000 1.000000 0.187500 0.000000 4.636358 0.000000 4.636358 29.942010 0.000000 29.942010 5.000000 0.000000 5 
-12.800000 1.000000 0.250000 0.000000 4.305714 0.000000 4.305714 45.956282 0.000001 45.956282 5.000000 0.000000 5 
-12.900000 1.000000 0.250000 0.000000 4.592360 -nan 4.592360 29.984001 0.000000 29.984001 5.000000 0.000000 5 
-13.000000 0.000000 0.000000 0.000000 4.908342 -nan 4.908342 29.444718 0.000000 29.444718 5.000000 0.000000 5 
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_cnProc.h b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_cnProc.h
index 2e0f53fdc1..379fc14056 100644
--- a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_cnProc.h
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_cnProc.h
@@ -1,3 +1,4 @@
+
 /*
  * Licensed to the OpenAirInterface (OAI) Software Alliance under one or more
  * contributor license agreements.  See the NOTICE file distributed with
@@ -37,6 +38,344 @@
    \param p_procBuf Pointer to processing buffers
    \param Z Lifting size
 */
+
+#define conditional_negate(a,b,z) _mm512_mask_sub_epi8(a,_mm512_movepi8_mask(b),z,a)
+
+#ifdef __AVX512BW__
+static inline void nrLDPC_cnProc_BG2_AVX512(t_nrLDPC_lut* p_lut, t_nrLDPC_procBuf* p_procBuf, uint16_t Z)
+{
+    const uint8_t*  lut_numCnInCnGroups   = p_lut->numCnInCnGroups;
+    const uint32_t* lut_startAddrCnGroups = p_lut->startAddrCnGroups;
+
+    int8_t* cnProcBuf    = p_procBuf->cnProcBuf;
+    int8_t* cnProcBufRes = p_procBuf->cnProcBufRes;
+
+    __m512i* p_cnProcBuf;
+    __m512i* p_cnProcBufRes;
+
+    // Number of CNs in Groups
+    uint32_t M;
+    uint32_t i;
+    uint32_t j;
+    uint32_t k;
+    // Offset to each bit within a group in terms of 32 Byte
+    uint32_t bitOffsetInGroup;
+
+    __m512i zmm0, min, sgn, zeros,maxLLR;
+    zeros  = _mm512_setzero_si512();
+     maxLLR = _mm512_set1_epi8((char)127);
+    __m512i* p_cnProcBufResBit;
+
+    const __m512i* p_ones   = (__m512i*) ones512_epi8;
+    const __m512i* p_maxLLR = (__m512i*) maxLLR512_epi8;
+
+    // LUT with offsets for bits that need to be processed
+    // 1. bit proc requires LLRs of 2. and 3. bit, 2.bits of 1. and 3. etc.
+    // Offsets are in units of bitOffsetInGroup
+    const uint8_t lut_idxCnProcG3[3][2] = {{72,144}, {0,144}, {0,72}};
+
+    // =====================================================================
+    // Process group with 3 BNs
+
+    if (lut_numCnInCnGroups[0] > 0)
+    {
+        // Number of groups of 32 CNs for parallel processing
+        // Ceil for values not divisible by 32
+        M = (lut_numCnInCnGroups[0]*Z + 63)>>6;
+        // Set the offset to each bit within a group in terms of 32 Byte
+        bitOffsetInGroup = (lut_numCnInCnGroups_BG2_R15[0]*NR_LDPC_ZMAX)>>6;
+
+        // Set pointers to start of group 3
+        p_cnProcBuf    = (__m512i*) &cnProcBuf   [lut_startAddrCnGroups[0]];
+        p_cnProcBufRes = (__m512i*) &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);
+
+            __m512i *pj0 = &p_cnProcBuf[lut_idxCnProcG3[j][0]/2];
+            __m512i *pj1 = &p_cnProcBuf[lut_idxCnProcG3[j][1]/2];
+
+            // Loop over CNs
+            for (i=0; i<M; i++)
+            {
+                // Abs and sign of 32 CNs (first BN)
+              //                zmm0 = p_cnProcBuf[lut_idxCnProcG3[j][0] + i];
+                zmm0 = pj0[i];
+                sgn  = _mm512_xor_si512(*p_ones, zmm0);
+                min  = _mm512_abs_epi8(zmm0);
+
+                // 32 CNs of second BN
+                //  zmm0 = p_cnProcBuf[lut_idxCnProcG3[j][1] + i];
+                zmm0 = pj1[i];
+                min  = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0));
+                sgn  = _mm512_xor_si512(sgn, zmm0);
+
+                // Store result
+                min = _mm512_min_epu8(min, *p_maxLLR); // 128 in epi8 is -127
+                *p_cnProcBufResBit = conditional_negate(min, sgn,zeros);
+                p_cnProcBufResBit++;
+                //p_cnProcBufResBit[i]=_mm512_sign_epi8(min, sgn);
+            }
+        }
+    }
+
+    // =====================================================================
+    // Process group with 4 BNs
+
+    // Offset is 20*384/32 = 240
+    const uint16_t lut_idxCnProcG4[4][3] = {{240,480,720}, {0,480,720}, {0,240,720}, {0,240,480}};
+
+    if (lut_numCnInCnGroups[1] > 0)
+    {
+        // Number of groups of 32 CNs for parallel processing
+        // Ceil for values not divisible by 32
+        M = (lut_numCnInCnGroups[1]*Z + 63)>>6;
+        // Set the offset to each bit within a group in terms of 32 Byte
+        bitOffsetInGroup = (lut_numCnInCnGroups_BG2_R15[1]*NR_LDPC_ZMAX)>>6;
+
+        // Set pointers to start of group 4
+        p_cnProcBuf    = (__m512i*) &cnProcBuf   [lut_startAddrCnGroups[1]];
+        p_cnProcBufRes = (__m512i*) &cnProcBufRes[lut_startAddrCnGroups[1]];
+
+        // Loop over every BN
+        for (j=0; j<4; j++)
+        {
+            // Set of results pointer to correct BN address
+            p_cnProcBufResBit = p_cnProcBufRes + (j*bitOffsetInGroup);
+
+            // Loop over CNs
+            for (i=0; i<M; i++)
+            {
+                // Abs and sign of 32 CNs (first BN)
+                zmm0 = p_cnProcBuf[lut_idxCnProcG4[j][0]/2 + i];
+                sgn  = _mm512_xor_si512(*p_ones, zmm0);
+                min  = _mm512_abs_epi8(zmm0);
+
+                // Loop over BNs
+                for (k=1; k<3; k++)
+                {
+                    zmm0 = p_cnProcBuf[lut_idxCnProcG4[j][k]/2 + i];
+                    min  = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0));
+                   sgn  = _mm512_xor_si512(sgn, zmm0);
+                }
+
+                // Store result
+                min = _mm512_min_epu8(min, *p_maxLLR); // 128 in epi8 is -127
+                *p_cnProcBufResBit = conditional_negate(min, sgn,zeros);
+                p_cnProcBufResBit++;
+            }
+        }
+    }
+
+    // =====================================================================
+    // Process group with 5 BNs
+
+    // Offset is 9*384/32 = 108
+    const uint16_t lut_idxCnProcG5[5][4] = {{108,216,324,432}, {0,216,324,432},
+                                            {0,108,324,432}, {0,108,216,432}, {0,108,216,324}};
+
+    if (lut_numCnInCnGroups[2] > 0)
+    {
+        // Number of groups of 32 CNs for parallel processing
+        // Ceil for values not divisible by 32
+        M = (lut_numCnInCnGroups[2]*Z + 63)>>6;
+        // Set the offset to each bit within a group in terms of 32 Byte
+        bitOffsetInGroup = (lut_numCnInCnGroups_BG2_R15[2]*NR_LDPC_ZMAX)>>6;
+
+        // Set pointers to start of group 5
+        p_cnProcBuf    = (__m512i*) &cnProcBuf   [lut_startAddrCnGroups[2]];
+        p_cnProcBufRes = (__m512i*) &cnProcBufRes[lut_startAddrCnGroups[2]];
+
+        // Loop over every BN
+        for (j=0; j<5; j++)
+        {
+            // Set of results pointer to correct BN address
+            p_cnProcBufResBit = p_cnProcBufRes + (j*bitOffsetInGroup);
+
+            // Loop over CNs
+            for (i=0; i<M; i++)
+            {
+                // Abs and sign of 32 CNs (first BN)
+                zmm0 = p_cnProcBuf[lut_idxCnProcG5[j][0]/2 + i];
+                sgn  = _mm512_xor_si512(*p_ones, zmm0);
+                min  = _mm512_abs_epi8(zmm0);
+
+                // Loop over BNs
+                for (k=1; k<4; k++)
+                {
+                    zmm0 = p_cnProcBuf[lut_idxCnProcG5[j][k]/2 + i];
+                    min  = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0));
+                   sgn  = _mm512_xor_si512(sgn, zmm0);
+                }
+
+                // Store result
+                min = _mm512_min_epu8(min, *p_maxLLR); // 128 in epi8 is -127
+                *p_cnProcBufResBit = conditional_negate(min, sgn,zeros);
+                p_cnProcBufResBit++;
+            }
+        }
+    }
+
+    // =====================================================================
+    // Process group with 6 BNs
+
+    // Offset is 3*384/32 = 36
+    const uint16_t lut_idxCnProcG6[6][5] = {{36,72,108,144,180}, {0,72,108,144,180},
+                                            {0,36,108,144,180}, {0,36,72,144,180},
+                                            {0,36,72,108,180}, {0,36,72,108,144}};
+
+    if (lut_numCnInCnGroups[3] > 0)
+    {
+        // Number of groups of 32 CNs for parallel processing
+        // Ceil for values not divisible by 32
+        M = (lut_numCnInCnGroups[3]*Z + 63)>>6;
+        // Set the offset to each bit within a group in terms of 32 Byte
+        bitOffsetInGroup = (lut_numCnInCnGroups_BG2_R15[3]*NR_LDPC_ZMAX)>>6;
+
+        // Set pointers to start of group 6
+        p_cnProcBuf    = (__m512i*) &cnProcBuf   [lut_startAddrCnGroups[3]];
+        p_cnProcBufRes = (__m512i*) &cnProcBufRes[lut_startAddrCnGroups[3]];
+
+        // Loop over every BN
+        for (j=0; j<6; j++)
+        {
+            // Set of results pointer to correct BN address
+            p_cnProcBufResBit = p_cnProcBufRes + (j*bitOffsetInGroup);
+
+            // Loop over CNs
+            for (i=0; i<M; i++)
+            {
+                // Abs and sign of 32 CNs (first BN)
+                zmm0 = p_cnProcBuf[lut_idxCnProcG6[j][0]/2 + i];
+                sgn  = _mm512_xor_si512(*p_ones, zmm0);
+                min  = _mm512_abs_epi8(zmm0);
+
+                // Loop over BNs
+                for (k=1; k<5; k++)
+                {
+                    zmm0 = p_cnProcBuf[lut_idxCnProcG6[j][k]/2 + i];
+                    min  = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0));
+                   sgn  = _mm512_xor_si512(sgn, zmm0);
+                }
+
+                // Store result
+                min = _mm512_min_epu8(min, *p_maxLLR); // 128 in epi8 is -127
+                *p_cnProcBufResBit = conditional_negate(min, sgn,zeros);
+                p_cnProcBufResBit++;
+            }
+        }
+    }
+
+    // =====================================================================
+    // Process group with 8 BNs
+
+    // Offset is 2*384/32 = 24
+    const uint8_t lut_idxCnProcG8[8][7] = {{24,48,72,96,120,144,168}, {0,48,72,96,120,144,168},
+                                           {0,24,72,96,120,144,168}, {0,24,48,96,120,144,168},
+                                           {0,24,48,72,120,144,168}, {0,24,48,72,96,144,168},
+                                           {0,24,48,72,96,120,168}, {0,24,48,72,96,120,144}};
+
+    if (lut_numCnInCnGroups[4] > 0)
+    {
+        // Number of groups of 32 CNs for parallel processing
+        // Ceil for values not divisible by 32
+        M = (lut_numCnInCnGroups[4]*Z + 63)>>6;
+        // Set the offset to each bit within a group in terms of 32 Byte
+        bitOffsetInGroup = (lut_numCnInCnGroups_BG2_R15[4]*NR_LDPC_ZMAX)>>6;
+
+        // Set pointers to start of group 8
+        p_cnProcBuf    = (__m512i*) &cnProcBuf   [lut_startAddrCnGroups[4]];
+        p_cnProcBufRes = (__m512i*) &cnProcBufRes[lut_startAddrCnGroups[4]];
+
+        // Loop over every BN
+        for (j=0; j<8; j++)
+        {
+            // Set of results pointer to correct BN address
+            p_cnProcBufResBit = p_cnProcBufRes + (j*bitOffsetInGroup);
+
+            // Loop over CNs
+            for (i=0; i<M; i++)
+            {
+                // Abs and sign of 32 CNs (first BN)
+                zmm0 = p_cnProcBuf[lut_idxCnProcG8[j][0]/2 + i];
+                sgn  = _mm512_xor_si512(*p_ones, zmm0);
+                min  = _mm512_abs_epi8(zmm0);
+
+                // Loop over BNs
+                for (k=1; k<7; k++)
+                {
+                    zmm0 = p_cnProcBuf[lut_idxCnProcG8[j][k]/2 + i];
+                    min  = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0));
+                   sgn  = _mm512_xor_si512(sgn, zmm0);
+                }
+
+                // Store result
+                min = _mm512_min_epu8(min, *p_maxLLR); // 128 in epi8 is -127
+                *p_cnProcBufResBit = conditional_negate(min, sgn,zeros);
+                p_cnProcBufResBit++;
+            }
+        }
+    }
+
+    // =====================================================================
+    // Process group with 10 BNs
+
+    // Offset is 2*384/32 = 24
+    const uint8_t lut_idxCnProcG10[10][9] = {{24,48,72,96,120,144,168,192,216}, {0,48,72,96,120,144,168,192,216},
+                                             {0,24,72,96,120,144,168,192,216}, {0,24,48,96,120,144,168,192,216},
+                                             {0,24,48,72,120,144,168,192,216}, {0,24,48,72,96,144,168,192,216},
+                                             {0,24,48,72,96,120,168,192,216}, {0,24,48,72,96,120,144,192,216},
+                                             {0,24,48,72,96,120,144,168,216}, {0,24,48,72,96,120,144,168,192}};
+
+    if (lut_numCnInCnGroups[5] > 0)
+    {
+        // Number of groups of 32 CNs for parallel processing
+        // Ceil for values not divisible by 32
+        M = (lut_numCnInCnGroups[5]*Z + 63)>>6;
+        // Set the offset to each bit within a group in terms of 32 Byte
+        bitOffsetInGroup = (lut_numCnInCnGroups_BG2_R15[5]*NR_LDPC_ZMAX)>>6;
+
+        // Set pointers to start of group 10
+        p_cnProcBuf    = (__m512i*) &cnProcBuf   [lut_startAddrCnGroups[5]];
+        p_cnProcBufRes = (__m512i*) &cnProcBufRes[lut_startAddrCnGroups[5]];
+
+        // Loop over every BN
+        for (j=0; j<10; j++)
+        {
+            // Set of results pointer to correct BN address
+            p_cnProcBufResBit = p_cnProcBufRes + (j*bitOffsetInGroup);
+
+            // Loop over CNs
+            for (i=0; i<M; i++)
+            {
+                // Abs and sign of 32 CNs (first BN)
+                zmm0 = p_cnProcBuf[lut_idxCnProcG10[j][0]/2 + i];
+                sgn  = _mm512_xor_si512(*p_ones, zmm0);
+                min  = _mm512_abs_epi8(zmm0);
+
+                // Loop over BNs
+                for (k=1; k<9; k++)
+                {
+                    zmm0 = p_cnProcBuf[lut_idxCnProcG10[j][k]/2 + i];
+                    min  = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0));
+                   sgn  = _mm512_xor_si512(sgn, zmm0);
+                }
+
+                // Store result
+                min = _mm512_min_epu8(min, *p_maxLLR); // 128 in epi8 is -127
+                *p_cnProcBufResBit = conditional_negate(min, sgn,zeros);
+                p_cnProcBufResBit++;
+            }
+        }
+    }
+
+}
+
+#else
+
 static inline void nrLDPC_cnProc_BG2(t_nrLDPC_lut* p_lut, t_nrLDPC_procBuf* p_procBuf, uint16_t Z)
 {
     const uint8_t*  lut_numCnInCnGroups   = p_lut->numCnInCnGroups;
@@ -44,7 +383,7 @@ static inline void nrLDPC_cnProc_BG2(t_nrLDPC_lut* p_lut, t_nrLDPC_procBuf* p_pr
 
     int8_t* cnProcBuf    = p_procBuf->cnProcBuf;
     int8_t* cnProcBufRes = p_procBuf->cnProcBufRes;
-    
+
     __m256i* p_cnProcBuf;
     __m256i* p_cnProcBufRes;
 
@@ -95,14 +434,14 @@ static inline void nrLDPC_cnProc_BG2(t_nrLDPC_lut* p_lut, t_nrLDPC_procBuf* p_pr
             for (i=0; i<M; i++)
             {
                 // Abs and sign of 32 CNs (first BN)
-	      //                ymm0 = p_cnProcBuf[lut_idxCnProcG3[j][0] + i];
-	        ymm0 = pj0[i];
+              //                ymm0 = p_cnProcBuf[lut_idxCnProcG3[j][0] + i];
+                ymm0 = pj0[i];
                 sgn  = _mm256_sign_epi8(*p_ones, ymm0);
                 min  = _mm256_abs_epi8(ymm0);
 
                 // 32 CNs of second BN
-		//  ymm0 = p_cnProcBuf[lut_idxCnProcG3[j][1] + i];
-		ymm0 = pj1[i];
+                //  ymm0 = p_cnProcBuf[lut_idxCnProcG3[j][1] + i];
+                ymm0 = pj1[i];
                 min  = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0));
                 sgn  = _mm256_sign_epi8(sgn, ymm0);
 
@@ -110,7 +449,7 @@ static inline void nrLDPC_cnProc_BG2(t_nrLDPC_lut* p_lut, t_nrLDPC_procBuf* p_pr
                 min = _mm256_min_epu8(min, *p_maxLLR); // 128 in epi8 is -127
                 *p_cnProcBufResBit = _mm256_sign_epi8(min, sgn);
                 p_cnProcBufResBit++;
-		//p_cnProcBufResBit[i]=_mm256_sign_epi8(min, sgn);
+                //p_cnProcBufResBit[i]=_mm256_sign_epi8(min, sgn);
             }
         }
     }
@@ -367,11 +706,519 @@ static inline void nrLDPC_cnProc_BG2(t_nrLDPC_lut* p_lut, t_nrLDPC_procBuf* p_pr
 
 }
 
+#endif
+
 /**
    \brief Performs CN processing for BG1 on the CN processing buffer and stores the results in the CN processing results buffer.
    \param p_lut Pointer to decoder LUTs
    \param Z Lifting size
 */
+
+#ifdef __AVX512BW__
+
+
+static inline void nrLDPC_cnProc_BG1_AVX512(t_nrLDPC_lut* p_lut, t_nrLDPC_procBuf* p_procBuf, uint16_t Z)
+{
+    const uint8_t*  lut_numCnInCnGroups   = p_lut->numCnInCnGroups;
+    const uint32_t* lut_startAddrCnGroups = p_lut->startAddrCnGroups;
+
+    int8_t* cnProcBuf    = p_procBuf->cnProcBuf;
+    int8_t* cnProcBufRes = p_procBuf->cnProcBufRes;
+
+    __m512i* p_cnProcBuf;
+    __m512i* p_cnProcBufRes;
+
+    // Number of CNs in Groups
+    uint32_t M;
+    uint32_t i;
+    uint32_t j;
+    uint32_t k;
+    // Offset to each bit within a group in terms of 32 Byte
+    uint32_t bitOffsetInGroup;
+
+    __m512i zmm0, min, sgn, zeros,maxLLR;
+
+     zeros  = _mm512_setzero_si512();
+     maxLLR = _mm512_set1_epi8((char)127);
+    __m512i* p_cnProcBufResBit;
+
+
+    const __m512i* p_ones   = (__m512i*) ones512_epi8;
+    const __m512i* p_maxLLR = (__m512i*) maxLLR512_epi8;
+
+
+
+
+    // LUT with offsets for bits that need to be processed
+    // 1. bit proc requires LLRs of 2. and 3. bit, 2.bits of 1. and 3. etc.
+    // Offsets are in units of bitOffsetInGroup (1*384/32)
+    const uint8_t lut_idxCnProcG3[3][2] = {{12,24}, {0,24}, {0,12}};
+
+    // =====================================================================
+    // Process group with 3 BNs
+
+    if (lut_numCnInCnGroups[0] > 0)
+    {
+        // Number of groups of 32 CNs for parallel processing
+        // Ceil for values not divisible by 32
+        M = (lut_numCnInCnGroups[0]*Z + 63)>>6;
+
+        // Set the offset to each bit within a group in terms of 32 Byte
+        bitOffsetInGroup = (lut_numCnInCnGroups_BG1_R13[0]*NR_LDPC_ZMAX)>>6;
+
+        // Set pointers to start of group 3
+        p_cnProcBuf    = (__m512i*) &cnProcBuf   [lut_startAddrCnGroups[0]];
+        p_cnProcBufRes = (__m512i*) &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<M; i++)
+            {
+                // Abs and sign of 32 CNs (first BN)
+                zmm0 = p_cnProcBuf[(lut_idxCnProcG3[j][0]/2) + i];
+                sgn  = _mm512_xor_si512(*p_ones, zmm0);
+                min  = _mm512_abs_epi8(zmm0);
+
+                // 32 CNs of second BN
+                zmm0 = p_cnProcBuf[(lut_idxCnProcG3[j][1]/2) + i];
+                min  = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0));
+               sgn  = _mm512_xor_si512(sgn, zmm0);
+
+
+                // Store result
+                min = _mm512_min_epu8(min, *p_maxLLR); // 128 in epi8 is -127
+                *p_cnProcBufResBit = conditional_negate(min, sgn,zeros);
+                p_cnProcBufResBit++;
+            }
+        }
+    }
+
+    // =====================================================================
+    // Process group with 4 BNs
+
+    // Offset is 5*384/32 = 60
+    const uint8_t lut_idxCnProcG4[4][3] = {{60,120,180}, {0,120,180}, {0,60,180}, {0,60,120}};
+
+    if (lut_numCnInCnGroups[1] > 0)
+    {
+        // Number of groups of 32 CNs for parallel processing
+        // Ceil for values not divisible by 32
+        M = (lut_numCnInCnGroups[1]*Z + 63)>>6;
+
+        // Set the offset to each bit within a group in terms of 32 Byte
+        bitOffsetInGroup = (lut_numCnInCnGroups_BG1_R13[1]*NR_LDPC_ZMAX)>>6;
+
+        // Set pointers to start of group 4
+        p_cnProcBuf    = (__m512i*) &cnProcBuf   [lut_startAddrCnGroups[1]];
+        p_cnProcBufRes = (__m512i*) &cnProcBufRes[lut_startAddrCnGroups[1]];
+
+        // Loop over every BN
+        for (j=0; j<4; j++)
+        {
+            // Set of results pointer to correct BN address
+            p_cnProcBufResBit = p_cnProcBufRes + (j*bitOffsetInGroup);
+
+            // Loop over CNs
+            for (i=0; i<M; i++)
+            {
+                // Abs and sign of 32 CNs (first BN)
+                zmm0 = p_cnProcBuf[(lut_idxCnProcG4[j][0]/2) + i];
+                sgn  = _mm512_xor_si512(*p_ones, zmm0);
+                min  = _mm512_abs_epi8(zmm0);
+
+                // Loop over BNs
+                for (k=1; k<3; k++)
+                {
+                    zmm0 = p_cnProcBuf[(lut_idxCnProcG4[j][k]/2) + i];
+                    min  = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0));
+                   sgn  = _mm512_xor_si512(sgn, zmm0);
+                }
+
+                // Store result
+                min = _mm512_min_epu8(min, *p_maxLLR); // 128 in epi8 is -127
+                *p_cnProcBufResBit = conditional_negate(min, sgn,zeros);
+                p_cnProcBufResBit++;
+            }
+        }
+    }
+
+    // =====================================================================
+    // Process group with 5 BNs
+
+    // Offset is 18*384/32 = 216
+    const uint16_t lut_idxCnProcG5[5][4] = {{216,432,648,864}, {0,432,648,864},
+                                            {0,216,648,864}, {0,216,432,864}, {0,216,432,648}};
+
+    if (lut_numCnInCnGroups[2] > 0)
+    {
+        // Number of groups of 32 CNs for parallel processing
+        // Ceil for values not divisible by 32
+        M = (lut_numCnInCnGroups[2]*Z + 63)>>6;
+
+        // Set the offset to each bit within a group in terms of 32 Byte
+        bitOffsetInGroup = (lut_numCnInCnGroups_BG1_R13[2]*NR_LDPC_ZMAX)>>6;
+
+        // Set pointers to start of group 5
+        p_cnProcBuf    = (__m512i*) &cnProcBuf   [lut_startAddrCnGroups[2]];
+        p_cnProcBufRes = (__m512i*) &cnProcBufRes[lut_startAddrCnGroups[2]];
+
+        // Loop over every BN
+        for (j=0; j<5; j++)
+        {
+            // Set of results pointer to correct BN address
+            p_cnProcBufResBit = p_cnProcBufRes + (j*bitOffsetInGroup);
+
+            // Loop over CNs
+            for (i=0; i<M; i++)
+            {
+                // Abs and sign of 32 CNs (first BN)
+                zmm0 = p_cnProcBuf[(lut_idxCnProcG5[j][0]/2) + i];
+                sgn  = _mm512_xor_si512(*p_ones, zmm0);
+                min  = _mm512_abs_epi8(zmm0);
+
+                // Loop over BNs
+                for (k=1; k<4; k++)
+                {
+                    zmm0 = p_cnProcBuf[(lut_idxCnProcG5[j][k]/2) + i];
+                    min  = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0));
+                   sgn  = _mm512_xor_si512(sgn, zmm0);
+                }
+
+                // Store result
+                min = _mm512_min_epu8(min, *p_maxLLR); // 128 in epi8 is -127
+                *p_cnProcBufResBit = conditional_negate(min, sgn,zeros);
+                p_cnProcBufResBit++;
+            }
+        }
+    }
+
+    // =====================================================================
+    // Process group with 6 BNs
+
+    // Offset is 8*384/32 = 96
+    const uint16_t lut_idxCnProcG6[6][5] = {{96,192,288,384,480}, {0,192,288,384,480},
+                                            {0,96,288,384,480}, {0,96,192,384,480},
+                                            {0,96,192,288,480}, {0,96,192,288,384}};
+
+    if (lut_numCnInCnGroups[3] > 0)
+    {
+        // Number of groups of 32 CNs for parallel processing
+        // Ceil for values not divisible by 32
+        M = (lut_numCnInCnGroups[3]*Z + 63)>>6;
+
+        // Set the offset to each bit within a group in terms of 32 Byte
+        bitOffsetInGroup = (lut_numCnInCnGroups_BG1_R13[3]*NR_LDPC_ZMAX)>>6;
+
+        // Set pointers to start of group 6
+        p_cnProcBuf    = (__m512i*) &cnProcBuf   [lut_startAddrCnGroups[3]];
+        p_cnProcBufRes = (__m512i*) &cnProcBufRes[lut_startAddrCnGroups[3]];
+
+        // Loop over every BN
+        for (j=0; j<6; j++)
+        {
+            // Set of results pointer to correct BN address
+            p_cnProcBufResBit = p_cnProcBufRes + (j*bitOffsetInGroup);
+
+            // Loop over CNs
+            for (i=0; i<M; i++)
+            {
+                // Abs and sign of 32 CNs (first BN)
+                zmm0 = p_cnProcBuf[(lut_idxCnProcG6[j][0]/2) + i];
+                sgn  = _mm512_xor_si512(*p_ones, zmm0);
+                min  = _mm512_abs_epi8(zmm0);
+
+                // Loop over BNs
+                for (k=1; k<5; k++)
+                {
+                    zmm0 = p_cnProcBuf[(lut_idxCnProcG6[j][k]/2) + i];
+                    min  = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0));
+                   sgn  = _mm512_xor_si512(sgn, zmm0);
+                }
+
+                // Store result
+                min = _mm512_min_epu8(min, *p_maxLLR); // 128 in epi8 is -127
+                *p_cnProcBufResBit = conditional_negate(min, sgn,zeros);
+                p_cnProcBufResBit++;
+            }
+        }
+    }
+
+    // =====================================================================
+    // Process group with 7 BNs
+
+    // Offset is 5*384/32 = 60
+    const uint16_t lut_idxCnProcG7[7][6] = {{60,120,180,240,300,360}, {0,120,180,240,300,360},
+                                            {0,60,180,240,300,360},   {0,60,120,240,300,360},
+                                            {0,60,120,180,300,360},   {0,60,120,180,240,360},
+                                            {0,60,120,180,240,300}};
+
+    if (lut_numCnInCnGroups[4] > 0)
+    {
+        // Number of groups of 32 CNs for parallel processing
+        // Ceil for values not divisible by 32
+        M = (lut_numCnInCnGroups[4]*Z + 63)>>6;
+
+        // Set the offset to each bit within a group in terms of 32 Byte
+        bitOffsetInGroup = (lut_numCnInCnGroups_BG1_R13[4]*NR_LDPC_ZMAX)>>6;
+
+        // Set pointers to start of group 7
+        p_cnProcBuf    = (__m512i*) &cnProcBuf   [lut_startAddrCnGroups[4]];
+        p_cnProcBufRes = (__m512i*) &cnProcBufRes[lut_startAddrCnGroups[4]];
+
+        // Loop over every BN
+        for (j=0; j<7; j++)
+        {
+            // Set of results pointer to correct BN address
+            p_cnProcBufResBit = p_cnProcBufRes + (j*bitOffsetInGroup);
+
+            // Loop over CNs
+            for (i=0; i<M; i++)
+            {
+                // Abs and sign of 32 CNs (first BN)
+                zmm0 = p_cnProcBuf[(lut_idxCnProcG7[j][0]/2) + i];
+                sgn  = _mm512_xor_si512(*p_ones, zmm0);
+                min  = _mm512_abs_epi8(zmm0);
+
+                // Loop over BNs
+                for (k=1; k<6; k++)
+                {
+                    zmm0 = p_cnProcBuf[(lut_idxCnProcG7[j][k]/2) + i];
+                    min  = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0));
+                   sgn  = _mm512_xor_si512(sgn, zmm0);
+                }
+
+                // Store result
+                min = _mm512_min_epu8(min, *p_maxLLR); // 128 in epi8 is -127
+                *p_cnProcBufResBit = conditional_negate(min, sgn,zeros);
+                p_cnProcBufResBit++;
+            }
+        }
+    }
+
+    // =====================================================================
+    // Process group with 8 BNs
+
+    // Offset is 2*384/32 = 24
+    const uint8_t lut_idxCnProcG8[8][7] = {{24,48,72,96,120,144,168}, {0,48,72,96,120,144,168},
+                                           {0,24,72,96,120,144,168}, {0,24,48,96,120,144,168},
+                                           {0,24,48,72,120,144,168}, {0,24,48,72,96,144,168},
+                                           {0,24,48,72,96,120,168}, {0,24,48,72,96,120,144}};
+
+    if (lut_numCnInCnGroups[5] > 0)
+    {
+        // Number of groups of 32 CNs for parallel processing
+        // Ceil for values not divisible by 32
+        M = (lut_numCnInCnGroups[5]*Z + 63)>>6;
+
+        // Set the offset to each bit within a group in terms of 32 Byte
+        bitOffsetInGroup = (lut_numCnInCnGroups_BG1_R13[5]*NR_LDPC_ZMAX)>>6;
+
+        // Set pointers to start of group 8
+        p_cnProcBuf    = (__m512i*) &cnProcBuf   [lut_startAddrCnGroups[5]];
+        p_cnProcBufRes = (__m512i*) &cnProcBufRes[lut_startAddrCnGroups[5]];
+
+        // Loop over every BN
+        for (j=0; j<8; j++)
+        {
+            // Set of results pointer to correct BN address
+            p_cnProcBufResBit = p_cnProcBufRes + (j*bitOffsetInGroup);
+
+            // Loop over CNs
+            for (i=0; i<M; i++)
+            {
+                // Abs and sign of 32 CNs (first BN)
+                zmm0 = p_cnProcBuf[(lut_idxCnProcG8[j][0]/2) + i];
+                sgn  = _mm512_xor_si512(*p_ones, zmm0);
+                min  = _mm512_abs_epi8(zmm0);
+
+                // Loop over BNs
+                for (k=1; k<7; k++)
+                {
+                    zmm0 = p_cnProcBuf[(lut_idxCnProcG8[j][k]/2) + i];
+                    min  = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0));
+                   sgn  = _mm512_xor_si512(sgn, zmm0);
+                }
+
+                // Store result
+                min = _mm512_min_epu8(min, *p_maxLLR); // 128 in epi8 is -127
+                *p_cnProcBufResBit = conditional_negate(min, sgn,zeros);
+                p_cnProcBufResBit++;
+            }
+        }
+    }
+
+    // =====================================================================
+    // Process group with 9 BNs
+
+    // Offset is 2*384/32 = 24
+    const uint8_t lut_idxCnProcG9[9][8] = {{24,48,72,96,120,144,168,192}, {0,48,72,96,120,144,168,192},
+                                           {0,24,72,96,120,144,168,192}, {0,24,48,96,120,144,168,192},
+                                           {0,24,48,72,120,144,168,192}, {0,24,48,72,96,144,168,192},
+                                           {0,24,48,72,96,120,168,192}, {0,24,48,72,96,120,144,192},
+                                           {0,24,48,72,96,120,144,168}};
+
+    if (lut_numCnInCnGroups[6] > 0)
+    {
+        // Number of groups of 32 CNs for parallel processing
+        // Ceil for values not divisible by 32
+        M = (lut_numCnInCnGroups[6]*Z + 63)>>6;
+
+        // Set the offset to each bit within a group in terms of 32 Byte
+        bitOffsetInGroup = (lut_numCnInCnGroups_BG1_R13[6]*NR_LDPC_ZMAX)>>6;
+
+        // Set pointers to start of group 9
+        p_cnProcBuf    = (__m512i*) &cnProcBuf   [lut_startAddrCnGroups[6]];
+        p_cnProcBufRes = (__m512i*) &cnProcBufRes[lut_startAddrCnGroups[6]];
+
+        // Loop over every BN
+        for (j=0; j<9; j++)
+        {
+            // Set of results pointer to correct BN address
+            p_cnProcBufResBit = p_cnProcBufRes + (j*bitOffsetInGroup);
+
+            // Loop over CNs
+            for (i=0; i<M; i++)
+            {
+                // Abs and sign of 32 CNs (first BN)
+                zmm0 = p_cnProcBuf[(lut_idxCnProcG9[j][0]/2) + i];
+                sgn  = _mm512_xor_si512(*p_ones, zmm0);
+                min  = _mm512_abs_epi8(zmm0);
+
+                // Loop over BNs
+                for (k=1; k<8; k++)
+                {
+                    zmm0 = p_cnProcBuf[(lut_idxCnProcG9[j][k]/2) + i];
+                    min  = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0));
+                   sgn  = _mm512_xor_si512(sgn, zmm0);
+                }
+
+                // Store result
+                min = _mm512_min_epu8(min, *p_maxLLR); // 128 in epi8 is -127
+                *p_cnProcBufResBit = conditional_negate(min, sgn,zeros);
+                p_cnProcBufResBit++;
+            }
+        }
+    }
+
+    // =====================================================================
+    // Process group with 10 BNs
+
+    // Offset is 1*384/32 = 12
+    const uint8_t lut_idxCnProcG10[10][9] = {{12,24,36,48,60,72,84,96,108}, {0,24,36,48,60,72,84,96,108},
+                                             {0,12,36,48,60,72,84,96,108}, {0,12,24,48,60,72,84,96,108},
+                                             {0,12,24,36,60,72,84,96,108}, {0,12,24,36,48,72,84,96,108},
+                                             {0,12,24,36,48,60,84,96,108}, {0,12,24,36,48,60,72,96,108},
+                                             {0,12,24,36,48,60,72,84,108}, {0,12,24,36,48,60,72,84,96}};
+
+    if (lut_numCnInCnGroups[7] > 0)
+    {
+        // Number of groups of 32 CNs for parallel processing
+        // Ceil for values not divisible by 32
+        M = (lut_numCnInCnGroups[7]*Z + 63)>>6;
+
+        // Set the offset to each bit within a group in terms of 32 Byte
+        bitOffsetInGroup = (lut_numCnInCnGroups_BG1_R13[7]*NR_LDPC_ZMAX)>>6;
+
+        // Set pointers to start of group 10
+        p_cnProcBuf    = (__m512i*) &cnProcBuf   [lut_startAddrCnGroups[7]];
+        p_cnProcBufRes = (__m512i*) &cnProcBufRes[lut_startAddrCnGroups[7]];
+
+        // Loop over every BN
+        for (j=0; j<10; j++)
+        {
+            // Set of results pointer to correct BN address
+            p_cnProcBufResBit = p_cnProcBufRes + (j*bitOffsetInGroup);
+
+            // Loop over CNs
+            for (i=0; i<M; i++)
+            {
+                // Abs and sign of 32 CNs (first BN)
+                zmm0 = p_cnProcBuf[(lut_idxCnProcG10[j][0]/2) + i];
+                sgn  = _mm512_xor_si512(*p_ones, zmm0);
+                min  = _mm512_abs_epi8(zmm0);
+
+                // Loop over BNs
+                for (k=1; k<9; k++)
+                {
+                    zmm0 = p_cnProcBuf[(lut_idxCnProcG10[j][k]/2) + i];
+                    min  = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0));
+                   sgn  = _mm512_xor_si512(sgn, zmm0);
+                }
+
+                // Store result
+                min = _mm512_min_epu8(min, *p_maxLLR); // 128 in epi8 is -127
+                *p_cnProcBufResBit = conditional_negate(min, sgn,zeros);
+                p_cnProcBufResBit++;
+            }
+        }
+    }
+
+    // =====================================================================
+    // Process group with 19 BNs
+
+    // Offset is 4*384/32 = 12
+    const uint16_t lut_idxCnProcG19[19][18] = {{48,96,144,192,240,288,336,384,432,480,528,576,624,672,720,768,816,864}, {0,96,144,192,240,288,336,384,432,480,528,576,624,672,720,768,816,864},
+                                               {0,48,144,192,240,288,336,384,432,480,528,576,624,672,720,768,816,864}, {0,48,96,192,240,288,336,384,432,480,528,576,624,672,720,768,816,864},
+                                               {0,48,96,144,240,288,336,384,432,480,528,576,624,672,720,768,816,864}, {0,48,96,144,192,288,336,384,432,480,528,576,624,672,720,768,816,864},
+                                               {0,48,96,144,192,240,336,384,432,480,528,576,624,672,720,768,816,864}, {0,48,96,144,192,240,288,384,432,480,528,576,624,672,720,768,816,864},
+                                               {0,48,96,144,192,240,288,336,432,480,528,576,624,672,720,768,816,864}, {0,48,96,144,192,240,288,336,384,480,528,576,624,672,720,768,816,864},
+                                               {0,48,96,144,192,240,288,336,384,432,528,576,624,672,720,768,816,864}, {0,48,96,144,192,240,288,336,384,432,480,576,624,672,720,768,816,864},
+                                               {0,48,96,144,192,240,288,336,384,432,480,528,624,672,720,768,816,864}, {0,48,96,144,192,240,288,336,384,432,480,528,576,672,720,768,816,864},
+                                               {0,48,96,144,192,240,288,336,384,432,480,528,576,624,720,768,816,864}, {0,48,96,144,192,240,288,336,384,432,480,528,576,624,672,768,816,864},
+                                               {0,48,96,144,192,240,288,336,384,432,480,528,576,624,672,720,816,864}, {0,48,96,144,192,240,288,336,384,432,480,528,576,624,672,720,768,864},
+                                               {0,48,96,144,192,240,288,336,384,432,480,528,576,624,672,720,768,816}};
+
+    if (lut_numCnInCnGroups[8] > 0)
+    {
+        // Number of groups of 32 CNs for parallel processing
+        // Ceil for values not divisible by 32
+        M = (lut_numCnInCnGroups[8]*Z + 63)>>6;
+
+        // Set the offset to each bit within a group in terms of 32 Byte
+        bitOffsetInGroup = (lut_numCnInCnGroups_BG1_R13[8]*NR_LDPC_ZMAX)>>6;
+
+        // Set pointers to start of group 19
+        p_cnProcBuf    = (__m512i*) &cnProcBuf   [lut_startAddrCnGroups[8]];
+        p_cnProcBufRes = (__m512i*) &cnProcBufRes[lut_startAddrCnGroups[8]];
+
+        // Loop over every BN
+        for (j=0; j<19; j++)
+        {
+            // Set of results pointer to correct BN address
+            p_cnProcBufResBit = p_cnProcBufRes + (j*bitOffsetInGroup);
+
+            // Loop over CNs
+            for (i=0; i<M; i++)
+            {
+                // Abs and sign of 32 CNs (first BN)
+                zmm0 = p_cnProcBuf[(lut_idxCnProcG19[j][0]/2) + i];
+                sgn  = _mm512_xor_si512(*p_ones, zmm0);
+                min  = _mm512_abs_epi8(zmm0);
+
+                // Loop over BNs
+                for (k=1; k<18; k++)
+                {
+                    zmm0 = p_cnProcBuf[(lut_idxCnProcG19[j][k]/2) + i];
+                    min  = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0));
+                   sgn  = _mm512_xor_si512(sgn, zmm0);
+                }
+
+                // Store result
+                min = _mm512_min_epu8(min, *p_maxLLR); // 128 in epi8 is -127
+                *p_cnProcBufResBit = conditional_negate(min, sgn,zeros);
+                p_cnProcBufResBit++;
+            }
+        }
+    }
+
+}
+
+#else
 static inline void nrLDPC_cnProc_BG1(t_nrLDPC_lut* p_lut, t_nrLDPC_procBuf* p_procBuf, uint16_t Z)
 {
     const uint8_t*  lut_numCnInCnGroups   = p_lut->numCnInCnGroups;
@@ -379,7 +1226,7 @@ static inline void nrLDPC_cnProc_BG1(t_nrLDPC_lut* p_lut, t_nrLDPC_procBuf* p_pr
 
     int8_t* cnProcBuf    = p_procBuf->cnProcBuf;
     int8_t* cnProcBufRes = p_procBuf->cnProcBufRes;
-    
+
     __m256i* p_cnProcBuf;
     __m256i* p_cnProcBufRes;
 
@@ -436,7 +1283,7 @@ static inline void nrLDPC_cnProc_BG1(t_nrLDPC_lut* p_lut, t_nrLDPC_procBuf* p_pr
                 ymm0 = p_cnProcBuf[lut_idxCnProcG3[j][1] + i];
                 min  = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0));
                 sgn  = _mm256_sign_epi8(sgn, ymm0);
-	     
+
 
                 // Store result
                 min = _mm256_min_epu8(min, *p_maxLLR); // 128 in epi8 is -127
@@ -865,7 +1712,7 @@ static inline void nrLDPC_cnProc_BG1(t_nrLDPC_lut* p_lut, t_nrLDPC_procBuf* p_pr
     }
 
 }
-
+#endif
 /**
    \brief Performs parity check for BG1 on the CN processing buffer. Stops as soon as error is detected.
    \param p_lut Pointer to decoder LUTs
@@ -879,7 +1726,7 @@ static inline uint32_t nrLDPC_cnProcPc_BG1(t_nrLDPC_lut* p_lut, t_nrLDPC_procBuf
 
     int8_t* cnProcBuf    = p_procBuf->cnProcBuf;
     int8_t* cnProcBufRes = p_procBuf->cnProcBufRes;
-    
+
     __m256i* p_cnProcBuf;
     __m256i* p_cnProcBufRes;
 
@@ -1514,7 +2361,7 @@ static inline uint32_t nrLDPC_cnProcPc_BG2(t_nrLDPC_lut* p_lut, t_nrLDPC_procBuf
 
     int8_t* cnProcBuf    = p_procBuf->cnProcBuf;
     int8_t* cnProcBufRes = p_procBuf->cnProcBufRes;
-    
+
     __m256i* p_cnProcBuf;
     __m256i* p_cnProcBufRes;
 
@@ -1935,3 +2782,6 @@ static inline uint32_t nrLDPC_cnProcPc_BG2(t_nrLDPC_lut* p_lut, t_nrLDPC_procBuf
 }
 
 #endif
+
+
+
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_decoder.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_decoder.c
index 0cbd58a40a..953e1c8ccc 100644
--- a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_decoder.c
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_decoder.c
@@ -34,244 +34,284 @@
 
 
   /*----------------------------------------------------------------------/
- /                  included files for -->AVX512                         /
+ /                 cn processing files -->AVX512                         /
 /----------------------------------------------------------------------*/
 
 //BG1-------------------------------------------------------------------
 #ifdef __AVX512BW__
-#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z384_13_AVX512.c"
-#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z352_13_AVX512.c"
-#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z320_13_AVX512.c"
-#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z288_13_AVX512.c"
-#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z256_13_AVX512.c"
-#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z240_13_AVX512.c"
-#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z224_13_AVX512.c"
-#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z208_13_AVX512.c"
-#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z192_13_AVX512.c"
-#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z176_13_AVX512.c"
+#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z384_R13_AVX512.c"
+#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z352_R13_AVX512.c"
+#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z320_R13_AVX512.c"
+#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z288_R13_AVX512.c"
+#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z256_R13_AVX512.c"
+#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z240_R13_AVX512.c"
+#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z224_R13_AVX512.c"
+#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z208_R13_AVX512.c"
+#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z192_R13_AVX512.c"
+#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z176_R13_AVX512.c"
 
-#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z160_13_AVX512.c"
-#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z144_13_AVX512.c"
-#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z128_13_AVX512.c"
-#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z120_13_AVX512.c"
-#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z112_13_AVX512.c"
-#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z104_13_AVX512.c"
-#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z96_13_AVX512.c"
-#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z88_13_AVX512.c"
-#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z80_13_AVX512.c"
-#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z72_13_AVX512.c"
+#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z160_R13_AVX512.c"
+#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z144_R13_AVX512.c"
+#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z128_R13_AVX512.c"
+#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z120_R13_AVX512.c"
+#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z112_R13_AVX512.c"
+#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z104_R13_AVX512.c"
+#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z96_R13_AVX512.c"
+#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z88_R13_AVX512.c"
+#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z80_R13_AVX512.c"
+#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z72_R13_AVX512.c"
 
-#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z64_13_AVX512.c"
-#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z60_13_AVX512.c"
-#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z56_13_AVX512.c"
-#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z52_13_AVX512.c"
-#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z48_13_AVX512.c"
-#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z44_13_AVX512.c"
-#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z40_13_AVX512.c"
-#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z36_13_AVX512.c"
-#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z32_13_AVX512.c"
-#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z30_13_AVX512.c"
+#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z64_R13_AVX512.c"
+#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z60_R13_AVX512.c"
+#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z56_R13_AVX512.c"
+#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z52_R13_AVX512.c"
+#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z48_R13_AVX512.c"
+#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z44_R13_AVX512.c"
+#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z40_R13_AVX512.c"
+#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z36_R13_AVX512.c"
+#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z32_R13_AVX512.c"
+#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z30_R13_AVX512.c"
 
-#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z28_13_AVX512.c"
-#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z26_13_AVX512.c"
-#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z24_13_AVX512.c"
-#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z22_13_AVX512.c"
-#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z20_13_AVX512.c"
-#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z18_13_AVX512.c"
-#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z16_13_AVX512.c"
-#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z15_13_AVX512.c"
-#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z14_13_AVX512.c"
-#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z13_13_AVX512.c"
+#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z28_R13_AVX512.c"
+#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z26_R13_AVX512.c"
+#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z24_R13_AVX512.c"
+#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z22_R13_AVX512.c"
+#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z20_R13_AVX512.c"
+#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z18_R13_AVX512.c"
+#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z16_R13_AVX512.c"
+#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z15_R13_AVX512.c"
+#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z14_R13_AVX512.c"
+#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z13_R13_AVX512.c"
 
-#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z12_13_AVX512.c"
-#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z11_13_AVX512.c"
-#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z10_13_AVX512.c"
-#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z9_13_AVX512.c"
-#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z8_13_AVX512.c"
-#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z7_13_AVX512.c"
-#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z6_13_AVX512.c"
-#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z5_13_AVX512.c"
-#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z4_13_AVX512.c"
-#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z3_13_AVX512.c"
-#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z2_13_AVX512.c"
+#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z12_R13_AVX512.c"
+#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z11_R13_AVX512.c"
+#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z10_R13_AVX512.c"
+#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z9_R13_AVX512.c"
+#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z8_R13_AVX512.c"
+#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z7_R13_AVX512.c"
+#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z6_R13_AVX512.c"
+#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z5_R13_AVX512.c"
+#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z4_R13_AVX512.c"
+#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z3_R13_AVX512.c"
+#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z2_R13_AVX512.c"
 
 //BG2------------------------------------------------------------------
-#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z384_15_AVX512.c"
-#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z352_15_AVX512.c"
-#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z320_15_AVX512.c"
-#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z288_15_AVX512.c"
-#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z256_15_AVX512.c"
-#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z240_15_AVX512.c"
-#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z224_15_AVX512.c"
-#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z208_15_AVX512.c"
-#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z192_15_AVX512.c"
-#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z176_15_AVX512.c"
+#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z384_R15_AVX512.c"
+#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z352_R15_AVX512.c"
+#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z320_R15_AVX512.c"
+#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z288_R15_AVX512.c"
+#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z256_R15_AVX512.c"
+#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z240_R15_AVX512.c"
+#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z224_R15_AVX512.c"
+#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z208_R15_AVX512.c"
+#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z192_R15_AVX512.c"
+#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z176_R15_AVX512.c"
 
-#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z160_15_AVX512.c"
-#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z144_15_AVX512.c"
-#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z128_15_AVX512.c"
-#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z120_15_AVX512.c"
-#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z112_15_AVX512.c"
-#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z104_15_AVX512.c"
-#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z96_15_AVX512.c"
-#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z88_15_AVX512.c"
-#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z80_15_AVX512.c"
-#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z72_15_AVX512.c"
+#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z160_R15_AVX512.c"
+#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z144_R15_AVX512.c"
+#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z128_R15_AVX512.c"
+#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z120_R15_AVX512.c"
+#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z112_R15_AVX512.c"
+#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z104_R15_AVX512.c"
+#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z96_R15_AVX512.c"
+#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z88_R15_AVX512.c"
+#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z80_R15_AVX512.c"
+#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z72_R15_AVX512.c"
 
-#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z64_15_AVX512.c"
-#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z60_15_AVX512.c"
-#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z56_15_AVX512.c"
-#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z52_15_AVX512.c"
-#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z48_15_AVX512.c"
-#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z44_15_AVX512.c"
-#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z40_15_AVX512.c"
-#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z36_15_AVX512.c"
-#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z32_15_AVX512.c"
-#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z30_15_AVX512.c"
+#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z64_R15_AVX512.c"
+#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z60_R15_AVX512.c"
+#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z56_R15_AVX512.c"
+#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z52_R15_AVX512.c"
+#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z48_R15_AVX512.c"
+#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z44_R15_AVX512.c"
+#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z40_R15_AVX512.c"
+#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z36_R15_AVX512.c"
+#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z32_R15_AVX512.c"
+#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z30_R15_AVX512.c"
 
-#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z28_15_AVX512.c"
-#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z26_15_AVX512.c"
-#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z24_15_AVX512.c"
-#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z22_15_AVX512.c"
-#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z20_15_AVX512.c"
-#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z18_15_AVX512.c"
-#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z16_15_AVX512.c"
-#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z15_15_AVX512.c"
-#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z14_15_AVX512.c"
-#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z13_15_AVX512.c"
+#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z28_R15_AVX512.c"
+#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z26_R15_AVX512.c"
+#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z24_R15_AVX512.c"
+#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z22_R15_AVX512.c"
+#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z20_R15_AVX512.c"
+#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z18_R15_AVX512.c"
+#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z16_R15_AVX512.c"
+#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z15_R15_AVX512.c"
+#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z14_R15_AVX512.c"
+#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z13_R15_AVX512.c"
 
-#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z12_15_AVX512.c"
-#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z11_15_AVX512.c"
-#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z10_15_AVX512.c"
-#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z9_15_AVX512.c"
-#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z8_15_AVX512.c"
-#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z7_15_AVX512.c"
-#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z6_15_AVX512.c"
-#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z5_15_AVX512.c"
-#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z4_15_AVX512.c"
-#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z3_15_AVX512.c"
-#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z2_15_AVX512.c"
+#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z12_R15_AVX512.c"
+#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z11_R15_AVX512.c"
+#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z10_R15_AVX512.c"
+#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z9_R15_AVX512.c"
+#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z8_R15_AVX512.c"
+#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z7_R15_AVX512.c"
+#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z6_R15_AVX512.c"
+#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z5_R15_AVX512.c"
+#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z4_R15_AVX512.c"
+#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z3_R15_AVX512.c"
+#include "nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z2_R15_AVX512.c"
 
 #else
 
   /*----------------------------------------------------------------------/
- /                  included files for -->AVX2                           /
+ /                  cn Processing files -->AVX2                           /
 /----------------------------------------------------------------------*/
 
 //BG1------------------------------------------------------------------
-#include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z384_13_AVX2.c"
-#include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z352_13_AVX2.c"
-#include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z320_13_AVX2.c"
-#include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z288_13_AVX2.c"
-#include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z256_13_AVX2.c"
-#include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z240_13_AVX2.c"
-#include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z224_13_AVX2.c"
-#include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z208_13_AVX2.c"
-#include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z192_13_AVX2.c"
-#include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z176_13_AVX2.c"
+#include "nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG1_Z384_R13_AVX2.c"
+#include "nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG1_Z352_R13_AVX2.c"
+#include "nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG1_Z320_R13_AVX2.c"
+#include "nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG1_Z288_R13_AVX2.c"
+#include "nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG1_Z256_R13_AVX2.c"
+#include "nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG1_Z240_R13_AVX2.c"
+#include "nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG1_Z224_R13_AVX2.c"
+#include "nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG1_Z208_R13_AVX2.c"
+#include "nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG1_Z192_R13_AVX2.c"
+#include "nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG1_Z176_R13_AVX2.c"
 
-#include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z160_13_AVX2.c"
-#include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z144_13_AVX2.c"
-#include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z128_13_AVX2.c"
-#include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z120_13_AVX2.c"
-#include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z112_13_AVX2.c"
-#include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z104_13_AVX2.c"
-#include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z96_13_AVX2.c"
-#include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z88_13_AVX2.c"
-#include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z80_13_AVX2.c"
-#include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z72_13_AVX2.c"
+#include "nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG1_Z160_R13_AVX2.c"
+#include "nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG1_Z144_R13_AVX2.c"
+#include "nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG1_Z128_R13_AVX2.c"
+#include "nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG1_Z120_R13_AVX2.c"
+#include "nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG1_Z112_R13_AVX2.c"
+#include "nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG1_Z104_R13_AVX2.c"
+#include "nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG1_Z96_R13_AVX2.c"
+#include "nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG1_Z88_R13_AVX2.c"
+#include "nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG1_Z80_R13_AVX2.c"
+#include "nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG1_Z72_R13_AVX2.c"
 
-#include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z64_13_AVX2.c"
-#include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z60_13_AVX2.c"
-#include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z56_13_AVX2.c"
-#include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z52_13_AVX2.c"
-#include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z48_13_AVX2.c"
-#include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z44_13_AVX2.c"
-#include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z40_13_AVX2.c"
-#include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z36_13_AVX2.c"
-#include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z32_13_AVX2.c"
-#include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z30_13_AVX2.c"
+#include "nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG1_Z64_R13_AVX2.c"
+#include "nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG1_Z60_R13_AVX2.c"
+#include "nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG1_Z56_R13_AVX2.c"
+#include "nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG1_Z52_R13_AVX2.c"
+#include "nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG1_Z48_R13_AVX2.c"
+#include "nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG1_Z44_R13_AVX2.c"
+#include "nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG1_Z40_R13_AVX2.c"
+#include "nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG1_Z36_R13_AVX2.c"
+#include "nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG1_Z32_R13_AVX2.c"
+#include "nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG1_Z30_R13_AVX2.c"
 
-#include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z28_13_AVX2.c"
-#include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z26_13_AVX2.c"
-#include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z24_13_AVX2.c"
-#include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z22_13_AVX2.c"
-#include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z20_13_AVX2.c"
-#include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z18_13_AVX2.c"
-#include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z16_13_AVX2.c"
-#include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z15_13_AVX2.c"
-#include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z14_13_AVX2.c"
-#include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z13_13_AVX2.c"
+#include "nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG1_Z28_R13_AVX2.c"
+#include "nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG1_Z26_R13_AVX2.c"
+#include "nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG1_Z24_R13_AVX2.c"
+#include "nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG1_Z22_R13_AVX2.c"
+#include "nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG1_Z20_R13_AVX2.c"
+#include "nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG1_Z18_R13_AVX2.c"
+#include "nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG1_Z16_R13_AVX2.c"
+#include "nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG1_Z15_R13_AVX2.c"
+#include "nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG1_Z14_R13_AVX2.c"
+#include "nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG1_Z13_R13_AVX2.c"
 
-#include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z12_13_AVX2.c"
-#include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z11_13_AVX2.c"
-#include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z10_13_AVX2.c"
-#include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z9_13_AVX2.c"
-#include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z8_13_AVX2.c"
-#include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z7_13_AVX2.c"
-#include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z6_13_AVX2.c"
-#include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z5_13_AVX2.c"
-#include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z4_13_AVX2.c"
-#include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z3_13_AVX2.c"
-#include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z2_13_AVX2.c"
+#include "nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG1_Z12_R13_AVX2.c"
+#include "nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG1_Z11_R13_AVX2.c"
+#include "nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG1_Z10_R13_AVX2.c"
+#include "nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG1_Z9_R13_AVX2.c"
+#include "nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG1_Z8_R13_AVX2.c"
+#include "nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG1_Z7_R13_AVX2.c"
+#include "nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG1_Z6_R13_AVX2.c"
+#include "nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG1_Z5_R13_AVX2.c"
+#include "nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG1_Z4_R13_AVX2.c"
+#include "nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG1_Z3_R13_AVX2.c"
+#include "nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG1_Z2_R13_AVX2.c"
 
 //BG2 --------------------------------------------------------------------
-#include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z384_15_AVX2.c"
-#include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z352_15_AVX2.c"
-#include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z320_15_AVX2.c"
-#include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z288_15_AVX2.c"
-#include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z256_15_AVX2.c"
-#include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z240_15_AVX2.c"
-#include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z224_15_AVX2.c"
-#include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z208_15_AVX2.c"
-#include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z192_15_AVX2.c"
-#include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z176_15_AVX2.c"
+#include "nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z384_R15_AVX2.c"
+#include "nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z352_R15_AVX2.c"
+#include "nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z320_R15_AVX2.c"
+#include "nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z288_R15_AVX2.c"
+#include "nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z256_R15_AVX2.c"
+#include "nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z240_R15_AVX2.c"
+#include "nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z224_R15_AVX2.c"
+#include "nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z208_R15_AVX2.c"
+#include "nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z192_R15_AVX2.c"
+#include "nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z176_R15_AVX2.c"
 
-#include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z160_15_AVX2.c"
-#include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z144_15_AVX2.c"
-#include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z128_15_AVX2.c"
-#include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z120_15_AVX2.c"
-#include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z112_15_AVX2.c"
-#include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z104_15_AVX2.c"
-#include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z96_15_AVX2.c"
-#include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z88_15_AVX2.c"
-#include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z80_15_AVX2.c"
-#include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z72_15_AVX2.c"
+#include "nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z160_R15_AVX2.c"
+#include "nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z144_R15_AVX2.c"
+#include "nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z128_R15_AVX2.c"
+#include "nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z120_R15_AVX2.c"
+#include "nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z112_R15_AVX2.c"
+#include "nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z104_R15_AVX2.c"
+#include "nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z96_R15_AVX2.c"
+#include "nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z88_R15_AVX2.c"
+#include "nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z80_R15_AVX2.c"
+#include "nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z72_R15_AVX2.c"
 
-#include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z64_15_AVX2.c"
-#include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z60_15_AVX2.c"
-#include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z56_15_AVX2.c"
-#include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z52_15_AVX2.c"
-#include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z48_15_AVX2.c"
-#include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z44_15_AVX2.c"
-#include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z40_15_AVX2.c"
-#include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z36_15_AVX2.c"
-#include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z32_15_AVX2.c"
-#include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z30_15_AVX2.c"
+#include "nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z64_R15_AVX2.c"
+#include "nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z60_R15_AVX2.c"
+#include "nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z56_R15_AVX2.c"
+#include "nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z52_R15_AVX2.c"
+#include "nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z48_R15_AVX2.c"
+#include "nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z44_R15_AVX2.c"
+#include "nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z40_R15_AVX2.c"
+#include "nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z36_R15_AVX2.c"
+#include "nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z32_R15_AVX2.c"
+#include "nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z30_R15_AVX2.c"
 
-#include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z28_15_AVX2.c"
-#include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z26_15_AVX2.c"
-#include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z24_15_AVX2.c"
-#include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z22_15_AVX2.c"
-#include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z20_15_AVX2.c"
-#include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z18_15_AVX2.c"
-#include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z16_15_AVX2.c"
-#include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z15_15_AVX2.c"
-#include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z14_15_AVX2.c"
-#include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z13_15_AVX2.c"
+#include "nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z28_R15_AVX2.c"
+#include "nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z26_R15_AVX2.c"
+#include "nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z24_R15_AVX2.c"
+#include "nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z22_R15_AVX2.c"
+#include "nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z20_R15_AVX2.c"
+#include "nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z18_R15_AVX2.c"
+#include "nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z16_R15_AVX2.c"
+#include "nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z15_R15_AVX2.c"
+#include "nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z14_R15_AVX2.c"
+#include "nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z13_R15_AVX2.c"
 
-#include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z12_15_AVX2.c"
-#include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z11_15_AVX2.c"
-#include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z10_15_AVX2.c"
-#include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z9_15_AVX2.c"
-#include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z8_15_AVX2.c"
-#include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z7_15_AVX2.c"
-#include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z6_15_AVX2.c"
-#include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z5_15_AVX2.c"
-#include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z4_15_AVX2.c"
-#include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z3_15_AVX2.c"
-#include "nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z2_15_AVX2.c"
+#include "nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z12_R15_AVX2.c"
+#include "nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z11_R15_AVX2.c"
+#include "nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z10_R15_AVX2.c"
+#include "nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z9_R15_AVX2.c"
+#include "nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z8_R15_AVX2.c"
+#include "nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z7_R15_AVX2.c"
+#include "nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z6_R15_AVX2.c"
+#include "nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z5_R15_AVX2.c"
+#include "nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z4_R15_AVX2.c"
+#include "nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z3_R15_AVX2.c"
+#include "nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z2_R15_AVX2.c"
 #endif
+//Bn Processing  files
+#include "nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z384_R13_AVX2.c"
+#include "nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z256_R13_AVX2.c"
+#include "nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z192_R13_AVX2.c"
+#include "nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z128_R13_AVX2.c"
+#include "nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z96_R13_AVX2.c"
+#include "nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z64_R13_AVX2.c"
+#include "nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z48_R13_AVX2.c"
+#include "nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z32_R13_AVX2.c"
+#include "nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z24_R13_AVX2.c"
+#include "nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z16_R13_AVX2.c"
+#include "nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z12_R13_AVX2.c"
+#include "nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z8_R13_AVX2.c"
+#include "nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z6_R13_AVX2.c"
+#include "nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z4_R13_AVX2.c"
+#include "nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z3_R13_AVX2.c"
+#include "nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z2_R13_AVX2.c"
+
+#include "nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z384_R15_AVX2.c"
+#include "nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z256_R15_AVX2.c"
+#include "nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z192_R15_AVX2.c"
+#include "nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z128_R15_AVX2.c"
+#include "nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z96_R15_AVX2.c"
+#include "nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z64_R15_AVX2.c"
+#include "nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z48_R15_AVX2.c"
+#include "nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z32_R15_AVX2.c"
+#include "nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z24_R15_AVX2.c"
+#include "nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z16_R15_AVX2.c"
+#include "nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z12_R15_AVX2.c"
+#include "nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z8_R15_AVX2.c"
+#include "nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z6_R15_AVX2.c"
+#include "nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z4_R15_AVX2.c"
+#include "nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z3_R15_AVX2.c"
+#include "nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z2_R15_AVX2.c"
+
+///#include "nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z384_R13_AVX2.c"
+//#include "nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z384_R15_AVX2.c"
+
+
+
 
 #define NR_LDPC_ENABLE_PARITY_CHECK
 #define NR_LDPC_PROFILER_DETAIL
@@ -385,18 +425,18 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 384:
             {
                 #ifdef __AVX512BW__
-             	nrLDPC_cnProc_BG1_Z384_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+             	nrLDPC_cnProc_BG1_Z384_R13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                	#else
-                nrLDPC_cnProc_BG1_Z384_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z384_R13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                	#endif                                                                                                                                                                        
                 break;
             }
             case 352:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG1_Z352_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z352_R13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG1_Z352_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z352_R13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -404,9 +444,9 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 320:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG1_Z320_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z320_R13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG1_Z320_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z320_R13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -414,9 +454,9 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 288:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG1_Z288_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z288_R13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG1_Z288_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z288_R13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -424,9 +464,9 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 256:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG1_Z256_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z256_R13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG1_Z256_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z256_R13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -434,9 +474,9 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 240:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG1_Z240_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z240_R13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG1_Z240_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z240_R13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -445,9 +485,9 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             {
 
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG1_Z224_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z224_R13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG1_Z224_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z224_R13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -455,9 +495,9 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 208:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG1_Z208_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z208_R13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG1_Z208_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z208_R13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -465,9 +505,9 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 192:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG1_Z192_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z192_R13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG1_Z192_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z192_R13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -475,9 +515,9 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 176:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG1_Z176_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z176_R13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG1_Z176_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z176_R13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -485,27 +525,27 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 160:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG1_Z176_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z176_R13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG1_Z176_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z176_R13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
             case 144:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG1_Z144_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z144_R13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG1_Z144_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z144_R13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
             case 128:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG1_Z128_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z128_R13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG1_Z128_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z128_R13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -513,9 +553,9 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 120:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG1_Z120_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z120_R13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
             #else
-             nrLDPC_cnProc_BG1_Z120_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+             nrLDPC_cnProc_BG1_Z120_R13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -523,9 +563,9 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 112:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG1_Z112_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z112_R13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG1_Z112_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z112_R13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -534,27 +574,27 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 104:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG1_Z104_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z104_R13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG1_Z104_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z104_R13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
             case 96:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG1_Z96_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z96_R13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG1_Z96_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z96_R13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
             case 88:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG1_Z88_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z88_R13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG1_Z88_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z88_R13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -562,9 +602,9 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 80:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG1_Z80_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z80_R13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG1_Z80_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z80_R13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -572,9 +612,9 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 72:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG1_Z72_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z72_R13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG1_Z72_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z72_R13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -582,9 +622,9 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 64:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG1_Z64_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z64_R13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG1_Z64_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z64_R13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -592,27 +632,27 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 60:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG1_Z60_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z60_R13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG1_Z60_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z60_R13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
             case 56:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG1_Z56_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z56_R13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG1_Z56_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z56_R13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
             case 52:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG1_Z52_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z52_R13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG1_Z52_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z52_R13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -620,9 +660,9 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 48:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG1_Z48_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z48_R13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG1_Z48_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z48_R13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -630,18 +670,18 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 44:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG1_Z44_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z44_R13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG1_Z44_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z44_R13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
             case 40:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG1_Z40_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z40_R13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG1_Z40_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z40_R13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -649,36 +689,36 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 36:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG1_Z36_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z36_R13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG1_Z36_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z36_R13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
             case 32:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG1_Z32_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z32_R13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG1_Z32_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z32_R13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
             case 30:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG1_Z30_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z30_R13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG1_Z30_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z30_R13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
             case 28:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG1_Z28_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z28_R13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG1_Z28_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z28_R13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -686,9 +726,9 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 26:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG1_Z26_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z26_R13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG1_Z26_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z26_R13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -696,9 +736,9 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 24:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG1_Z24_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z24_R13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG1_Z24_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z24_R13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -706,27 +746,27 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 22:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG1_Z22_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z22_R13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG1_Z22_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z22_R13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
             case 20:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG1_Z20_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z20_R13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG1_Z20_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z20_R13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
             case 18:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG1_Z18_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z18_R13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG1_Z18_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z18_R13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -734,27 +774,27 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 16:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG1_Z16_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z16_R13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG1_Z16_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z16_R13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
             case 15:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG1_Z15_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z15_R13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG1_Z15_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z15_R13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
             case 14:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG1_Z14_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z14_R13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG1_Z14_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z14_R13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -762,9 +802,9 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 13:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG1_Z13_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z13_R13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG1_Z13_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z13_R13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -772,9 +812,9 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 12:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG1_Z12_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z12_R13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG1_Z12_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z12_R13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -782,18 +822,18 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 11:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG1_Z11_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z11_R13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG1_Z11_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z11_R13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
             case 10:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG1_Z10_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z10_R13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG1_Z10_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z10_R13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -801,9 +841,9 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 9:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG1_Z9_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z9_R13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG1_Z9_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z9_R13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -811,9 +851,9 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 8:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG1_Z8_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z8_R13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG1_Z8_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z8_R13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -821,9 +861,9 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 7:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG1_Z7_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z7_R13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG1_Z7_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z7_R13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -831,9 +871,9 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 6:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG1_Z6_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z6_R13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG1_Z6_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z6_R13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -841,9 +881,9 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 5:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG1_Z5_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z5_R13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG1_Z5_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z5_R13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -851,9 +891,9 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 4:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG1_Z4_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z4_R13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG1_Z4_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z4_R13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -861,18 +901,18 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 3:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG1_Z3_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z3_R13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG1_Z3_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z3_R13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
             case 2:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG1_Z2_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z2_R13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG1_Z2_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z2_R13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -885,18 +925,18 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 384:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG2_Z384_15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z384_R15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG2_Z384_15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z384_R15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
             case 352:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG2_Z352_15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z352_R15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG2_Z352_15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z352_R15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -904,9 +944,9 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 320:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG2_Z320_15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z320_R15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG2_Z320_15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z320_R15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -914,9 +954,9 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 288:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG2_Z288_15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z288_R15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG2_Z288_15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z288_R15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -924,9 +964,9 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 256:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG2_Z256_15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z256_R15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG2_Z256_15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z256_R15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -934,9 +974,9 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 240:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG2_Z240_15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z240_R15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
             #else
-             nrLDPC_cnProc_BG2_Z240_15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+             nrLDPC_cnProc_BG2_Z240_R15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -945,9 +985,9 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             {
 
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG2_Z224_15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z224_R15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG2_Z224_15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z224_R15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -955,9 +995,9 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 208:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG2_Z208_15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z208_R15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG2_Z208_15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z208_R15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -965,9 +1005,9 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 192:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG2_Z192_15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z192_R15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG2_Z192_15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z192_R15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -975,9 +1015,9 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 176:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG2_Z176_15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z176_R15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG2_Z176_15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z176_R15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -985,27 +1025,27 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 160:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG2_Z176_15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z176_R15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG2_Z176_15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z176_R15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
             case 144:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG2_Z144_15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z144_R15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG2_Z144_15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z144_R15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
             case 128:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG2_Z128_15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z128_R15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                 nrLDPC_cnProc_BG2_Z128_15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                 nrLDPC_cnProc_BG2_Z128_R15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -1013,9 +1053,9 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 120:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG2_Z120_15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z120_R15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
             #else
-             nrLDPC_cnProc_BG2_Z120_15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+             nrLDPC_cnProc_BG2_Z120_R15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -1023,9 +1063,9 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 112:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG2_Z112_15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z112_R15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG2_Z112_15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z112_R15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -1034,27 +1074,27 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 104:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG2_Z104_15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z104_R15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG2_Z104_15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z104_R15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
             case 96:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG2_Z96_15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z96_R15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG2_Z96_15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z96_R15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
             case 88:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG2_Z88_15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z88_R15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG2_Z88_15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z88_R15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -1062,9 +1102,9 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 80:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG2_Z80_15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z80_R15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG2_Z80_15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z80_R15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -1072,9 +1112,9 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 72:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG2_Z72_15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z72_R15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG2_Z72_15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z72_R15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -1082,9 +1122,9 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 64:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG2_Z64_15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z64_R15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG2_Z64_15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z64_R15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -1092,27 +1132,27 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 60:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG2_Z60_15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z60_R15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG2_Z60_15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z60_R15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
             case 56:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG2_Z56_15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z56_R15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG2_Z56_15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z56_R15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
             case 52:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG2_Z52_15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z52_R15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG2_Z52_15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z52_R15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -1120,9 +1160,9 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 48:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG2_Z48_15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z48_R15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG2_Z48_15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z48_R15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -1130,18 +1170,18 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 44:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG2_Z44_15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z44_R15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG2_Z44_15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z44_R15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
             case 40:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG2_Z40_15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z40_R15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG2_Z40_15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z40_R15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -1149,36 +1189,36 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 36:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG2_Z36_15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z36_R15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG2_Z36_15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z36_R15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
             case 32:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG2_Z32_15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z32_R15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG2_Z32_15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z32_R15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
             case 30:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG2_Z30_15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z30_R15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG2_Z30_15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z30_R15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
             case 28:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG2_Z28_15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z28_R15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG2_Z28_15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z28_R15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -1186,9 +1226,9 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 26:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG2_Z26_15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z26_R15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG2_Z26_15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z26_R15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -1196,9 +1236,9 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 24:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG2_Z24_15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z24_R15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG2_Z24_15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z24_R15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -1206,27 +1246,27 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 22:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG2_Z22_15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z22_R15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG2_Z22_15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z22_R15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
             case 20:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG2_Z20_15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z20_R15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG2_Z20_15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z20_R15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
             case 18:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG2_Z18_15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z18_R15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG2_Z18_15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z18_R15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -1234,27 +1274,27 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 16:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG2_Z16_15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z16_R15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG2_Z16_15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z16_R15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
             case 15:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG2_Z15_15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z15_R15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG2_Z15_15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z15_R15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
             case 14:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG2_Z14_15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z14_R15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG2_Z14_15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z14_R15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -1262,9 +1302,9 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 13:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG2_Z13_15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z13_R15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG2_Z13_15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z13_R15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -1272,9 +1312,9 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 12:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG2_Z12_15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z12_R15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG2_Z12_15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z12_R15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -1282,18 +1322,18 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 11:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG2_Z11_15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z11_R15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG2_Z11_15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z11_R15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
             case 10:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG2_Z10_15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z10_R15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG2_Z10_15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z10_R15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -1301,9 +1341,9 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 9:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG2_Z9_15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z9_R15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG2_Z9_15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z9_R15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -1311,9 +1351,9 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 8:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG2_Z8_15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z8_R15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG2_Z8_15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z8_R15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -1321,9 +1361,9 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 7:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG2_Z7_15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z7_R15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG2_Z7_15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z7_R15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -1331,9 +1371,9 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 6:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG2_Z6_15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z6_R15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG2_Z6_15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z6_R15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -1341,9 +1381,9 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 5:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG2_Z5_15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z5_R15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG2_Z5_15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z5_R15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -1351,9 +1391,9 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 4:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG2_Z4_15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z4_R15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG2_Z4_15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z4_R15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -1361,18 +1401,18 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 3:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG2_Z3_15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z3_R15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG2_Z3_15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z3_R15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
             case 2:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG2_Z2_15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z2_R15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG2_Z2_15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z2_R15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -1411,7 +1451,120 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
 #ifdef NR_LDPC_PROFILER_DETAIL
     start_meas(&p_profiler->bnProcPc);
 #endif
-    nrLDPC_bnProcPc(p_lut, p_procBuf, Z);
+         if(BG==1){
+
+            switch (Z)
+            {
+                case 384:
+                {
+                    nrLDPC_bnProcPc_BG1_Z384_R13_AVX2(p_procBuf->bnProcBuf,p_procBuf->bnProcBufRes,  p_procBuf->llrRes , p_procBuf->llrProcBuf );                                                                                                                                                                       
+                    break;
+                }
+                case 256:
+                {
+                    nrLDPC_bnProcPc_BG1_Z256_R13_AVX2(p_procBuf->bnProcBuf,p_procBuf->bnProcBufRes,  p_procBuf->llrRes , p_procBuf->llrProcBuf );                                                                                                                                                                       
+                    break;
+                }
+
+                case 192:
+                {
+                    nrLDPC_bnProcPc_BG1_Z192_R13_AVX2(p_procBuf->bnProcBuf,p_procBuf->bnProcBufRes,  p_procBuf->llrRes , p_procBuf->llrProcBuf );                                                                                                                                                                       
+                    break;
+                }
+
+                case 128:
+                {
+                    nrLDPC_bnProcPc_BG1_Z128_R13_AVX2(p_procBuf->bnProcBuf,p_procBuf->bnProcBufRes,  p_procBuf->llrRes , p_procBuf->llrProcBuf );                                                                                                                                                                       
+                    break;
+                }
+
+                case 96:
+                {
+                    nrLDPC_bnProcPc_BG1_Z96_R13_AVX2(p_procBuf->bnProcBuf,p_procBuf->bnProcBufRes,  p_procBuf->llrRes , p_procBuf->llrProcBuf );                                                                                                                                                                       
+                    break;
+                }
+
+                case 64:
+                {
+                    nrLDPC_bnProcPc_BG1_Z64_R13_AVX2(p_procBuf->bnProcBuf,p_procBuf->bnProcBufRes,  p_procBuf->llrRes , p_procBuf->llrProcBuf );                                                                                                                                                                       
+                    break;
+                }
+                case 48:
+                {
+                    nrLDPC_bnProcPc_BG1_Z48_R13_AVX2(p_procBuf->bnProcBuf,p_procBuf->bnProcBufRes,  p_procBuf->llrRes , p_procBuf->llrProcBuf );                                                                                                                                                                       
+                    break;
+                }
+                case 32:
+                {
+                    nrLDPC_bnProcPc_BG1_Z32_R13_AVX2(p_procBuf->bnProcBuf,p_procBuf->bnProcBufRes,  p_procBuf->llrRes , p_procBuf->llrProcBuf );                                                                                                                                                                       
+                    break;
+                }
+                default :
+                {
+                    nrLDPC_bnProcPc(p_lut, p_procBuf, Z);                                                                                                                                                                       
+                    break;
+                }
+               
+            }
+        }
+        else{
+            switch (Z)
+            {
+                case 384:
+                {
+                    nrLDPC_bnProcPc_BG2_Z384_R15_AVX2(p_procBuf->bnProcBuf,p_procBuf->bnProcBufRes,  p_procBuf->llrRes , p_procBuf->llrProcBuf );                                                                                                                                                                       
+                    break;
+                }
+                case 256:
+                {
+                    nrLDPC_bnProcPc_BG2_Z256_R15_AVX2(p_procBuf->bnProcBuf,p_procBuf->bnProcBufRes,  p_procBuf->llrRes , p_procBuf->llrProcBuf );                                                                                                                                                                       
+                    break;
+                }
+
+                case 192:
+                {
+                    nrLDPC_bnProcPc_BG2_Z192_R15_AVX2(p_procBuf->bnProcBuf,p_procBuf->bnProcBufRes,  p_procBuf->llrRes , p_procBuf->llrProcBuf );                                                                                                                                                                       
+                    break;
+                }
+
+                case 128:
+                {
+                    nrLDPC_bnProcPc_BG2_Z128_R15_AVX2(p_procBuf->bnProcBuf,p_procBuf->bnProcBufRes,  p_procBuf->llrRes , p_procBuf->llrProcBuf );                                                                                                                                                                       
+                    break;
+                }
+
+                case 96:
+                {
+                    nrLDPC_bnProcPc_BG2_Z96_R15_AVX2(p_procBuf->bnProcBuf,p_procBuf->bnProcBufRes,  p_procBuf->llrRes , p_procBuf->llrProcBuf );                                                                                                                                                                       
+                    break;
+                }
+
+                case 64:
+                {
+                    nrLDPC_bnProcPc_BG2_Z64_R15_AVX2(p_procBuf->bnProcBuf,p_procBuf->bnProcBufRes,  p_procBuf->llrRes , p_procBuf->llrProcBuf );                                                                                                                                                                       
+                    break;
+                }
+
+                case 48:
+                {
+                    nrLDPC_bnProcPc_BG2_Z48_R15_AVX2(p_procBuf->bnProcBuf,p_procBuf->bnProcBufRes,  p_procBuf->llrRes , p_procBuf->llrProcBuf );                                                                                                                                                                       
+                    break;
+                }
+
+                case 32:
+                {
+                    nrLDPC_bnProcPc_BG2_Z32_R15_AVX2(p_procBuf->bnProcBuf,p_procBuf->bnProcBufRes,  p_procBuf->llrRes , p_procBuf->llrProcBuf );                                                                                                                                                                       
+                    break;
+                }
+                default :
+                {
+                    nrLDPC_bnProcPc(p_lut, p_procBuf, Z);                                                                                                                                                                       
+                    break;
+                }
+               
+            }
+        }
+        
 #ifdef NR_LDPC_PROFILER_DETAIL
     stop_meas(&p_profiler->bnProcPc);
 #endif
@@ -1476,18 +1629,18 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 384:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG1_Z384_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z384_R13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG1_Z384_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z384_R13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
             case 352:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG1_Z352_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z352_R13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG1_Z352_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z352_R13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -1495,9 +1648,9 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 320:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG1_Z320_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z320_R13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG1_Z320_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z320_R13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -1505,9 +1658,9 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 288:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG1_Z288_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z288_R13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG1_Z288_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z288_R13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -1515,9 +1668,9 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 256:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG1_Z256_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z256_R13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG1_Z256_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z256_R13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -1525,9 +1678,9 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 240:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG1_Z240_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z240_R13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG1_Z240_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z240_R13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -1536,9 +1689,9 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             {
 
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG1_Z224_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z224_R13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG1_Z224_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z224_R13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -1546,9 +1699,9 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 208:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG1_Z208_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z208_R13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG1_Z208_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z208_R13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -1556,9 +1709,9 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 192:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG1_Z192_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z192_R13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG1_Z192_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z192_R13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -1566,9 +1719,9 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 176:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG1_Z176_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z176_R13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG1_Z176_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z176_R13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -1576,27 +1729,27 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 160:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG1_Z176_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z176_R13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG1_Z176_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z176_R13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
             case 144:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG1_Z144_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z144_R13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG1_Z144_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z144_R13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
             case 128:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG1_Z128_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z128_R13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG1_Z128_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z128_R13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -1604,9 +1757,9 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 120:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG1_Z120_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z120_R13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
             #else
-             nrLDPC_cnProc_BG1_Z120_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+             nrLDPC_cnProc_BG1_Z120_R13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -1614,9 +1767,9 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 112:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG1_Z112_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z112_R13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG1_Z112_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z112_R13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -1625,27 +1778,27 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 104:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG1_Z104_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z104_R13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG1_Z104_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z104_R13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
             case 96:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG1_Z96_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z96_R13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG1_Z96_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z96_R13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
             case 88:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG1_Z88_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z88_R13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG1_Z88_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z88_R13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -1653,9 +1806,9 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 80:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG1_Z80_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z80_R13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG1_Z80_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z80_R13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -1663,9 +1816,9 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 72:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG1_Z72_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z72_R13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG1_Z72_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z72_R13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -1673,9 +1826,9 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 64:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG1_Z64_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z64_R13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG1_Z64_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z64_R13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -1683,27 +1836,27 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 60:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG1_Z60_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z60_R13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG1_Z60_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z60_R13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
             case 56:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG1_Z56_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z56_R13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG1_Z56_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z56_R13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
             case 52:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG1_Z52_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z52_R13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG1_Z52_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z52_R13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -1711,9 +1864,9 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 48:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG1_Z48_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z48_R13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG1_Z48_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z48_R13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -1721,18 +1874,18 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 44:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG1_Z44_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z44_R13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG1_Z44_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z44_R13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
             case 40:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG1_Z40_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z40_R13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG1_Z40_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z40_R13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -1740,36 +1893,36 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 36:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG1_Z36_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z36_R13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG1_Z36_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z36_R13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
             case 32:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG1_Z32_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z32_R13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG1_Z32_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z32_R13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
             case 30:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG1_Z30_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z30_R13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG1_Z30_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z30_R13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
             case 28:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG1_Z28_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z28_R13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG1_Z28_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z28_R13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -1777,9 +1930,9 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 26:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG1_Z26_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z26_R13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG1_Z26_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z26_R13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -1787,9 +1940,9 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 24:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG1_Z24_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z24_R13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG1_Z24_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z24_R13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -1797,27 +1950,27 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 22:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG1_Z22_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z22_R13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG1_Z22_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z22_R13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
             case 20:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG1_Z20_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z20_R13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG1_Z20_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z20_R13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
             case 18:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG1_Z18_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z18_R13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG1_Z18_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z18_R13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -1825,27 +1978,27 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 16:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG1_Z16_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z16_R13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG1_Z16_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z16_R13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
             case 15:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG1_Z15_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z15_R13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG1_Z15_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z15_R13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
             case 14:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG1_Z14_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z14_R13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG1_Z14_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z14_R13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -1853,9 +2006,9 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 13:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG1_Z13_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z13_R13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG1_Z13_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z13_R13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -1863,9 +2016,9 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 12:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG1_Z12_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z12_R13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG1_Z12_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z12_R13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -1873,18 +2026,18 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 11:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG1_Z11_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z11_R13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG1_Z11_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z11_R13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
             case 10:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG1_Z10_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z10_R13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG1_Z10_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z10_R13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -1892,9 +2045,9 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 9:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG1_Z9_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z9_R13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG1_Z9_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z9_R13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -1902,9 +2055,9 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 8:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG1_Z8_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z8_R13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG1_Z8_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z8_R13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -1912,9 +2065,9 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 7:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG1_Z7_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z7_R13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG1_Z7_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z7_R13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -1922,9 +2075,9 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 6:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG1_Z6_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z6_R13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG1_Z6_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z6_R13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -1932,9 +2085,9 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 5:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG1_Z5_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z5_R13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG1_Z5_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z5_R13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -1942,9 +2095,9 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 4:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG1_Z4_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z4_R13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG1_Z4_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z4_R13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -1952,18 +2105,18 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 3:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG1_Z3_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z3_R13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG1_Z3_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z3_R13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
             case 2:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG1_Z2_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z2_R13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG1_Z2_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z2_R13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -1976,18 +2129,18 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 384:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG2_Z384_15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z384_R15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG2_Z384_15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z384_R15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
             case 352:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG2_Z352_15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z352_R15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG2_Z352_15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z352_R15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -1995,9 +2148,9 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 320:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG2_Z320_15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z320_R15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG2_Z320_15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z320_R15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -2005,9 +2158,9 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 288:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG2_Z288_15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z288_R15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG2_Z288_15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z288_R15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -2015,9 +2168,9 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 256:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG2_Z256_15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z256_R15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG2_Z256_15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z256_R15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -2025,9 +2178,9 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 240:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG2_Z240_15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z240_R15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
             #else
-             nrLDPC_cnProc_BG2_Z240_15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+             nrLDPC_cnProc_BG2_Z240_R15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -2036,9 +2189,9 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             {
 
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG2_Z224_15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z224_R15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG2_Z224_15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z224_R15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -2046,9 +2199,9 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 208:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG2_Z208_15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z208_R15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG2_Z208_15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z208_R15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -2056,9 +2209,9 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 192:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG2_Z192_15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z192_R15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG2_Z192_15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z192_R15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -2066,9 +2219,9 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 176:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG2_Z176_15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z176_R15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG2_Z176_15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z176_R15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -2076,27 +2229,27 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 160:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG2_Z176_15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z176_R15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG2_Z176_15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z176_R15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
             case 144:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG2_Z144_15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z144_R15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG2_Z144_15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z144_R15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
             case 128:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG2_Z128_15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z128_R15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                 nrLDPC_cnProc_BG2_Z128_15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                 nrLDPC_cnProc_BG2_Z128_R15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -2104,9 +2257,9 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 120:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG2_Z120_15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z120_R15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
             #else
-             nrLDPC_cnProc_BG2_Z120_15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+             nrLDPC_cnProc_BG2_Z120_R15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -2114,9 +2267,9 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 112:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG2_Z112_15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z112_R15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG2_Z112_15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z112_R15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -2125,27 +2278,27 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 104:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG2_Z104_15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z104_R15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG2_Z104_15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z104_R15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
             case 96:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG2_Z96_15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z96_R15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG2_Z96_15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z96_R15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
             case 88:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG2_Z88_15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z88_R15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG2_Z88_15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z88_R15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -2153,9 +2306,9 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 80:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG2_Z80_15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z80_R15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG2_Z80_15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z80_R15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -2163,9 +2316,9 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 72:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG2_Z72_15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z72_R15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG2_Z72_15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z72_R15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -2173,9 +2326,9 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 64:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG2_Z64_15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z64_R15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG2_Z64_15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z64_R15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -2183,27 +2336,27 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 60:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG2_Z60_15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z60_R15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG2_Z60_15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z60_R15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
             case 56:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG2_Z56_15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z56_R15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG2_Z56_15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z56_R15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
             case 52:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG2_Z52_15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z52_R15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG2_Z52_15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z52_R15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -2211,9 +2364,9 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 48:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG2_Z48_15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z48_R15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG2_Z48_15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z48_R15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -2221,18 +2374,18 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 44:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG2_Z44_15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z44_R15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG2_Z44_15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z44_R15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
             case 40:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG2_Z40_15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z40_R15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG2_Z40_15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z40_R15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -2240,36 +2393,36 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 36:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG2_Z36_15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z36_R15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG2_Z36_15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z36_R15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
             case 32:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG2_Z32_15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z32_R15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG2_Z32_15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z32_R15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
             case 30:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG2_Z30_15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z30_R15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG2_Z30_15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z30_R15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
             case 28:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG2_Z28_15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z28_R15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG2_Z28_15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z28_R15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -2277,9 +2430,9 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 26:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG2_Z26_15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z26_R15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG2_Z26_15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z26_R15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -2287,9 +2440,9 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 24:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG2_Z24_15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z24_R15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG2_Z24_15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z24_R15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -2297,27 +2450,27 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 22:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG2_Z22_15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z22_R15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG2_Z22_15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z22_R15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
             case 20:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG2_Z20_15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z20_R15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG2_Z20_15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z20_R15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
             case 18:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG2_Z18_15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z18_R15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG2_Z18_15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z18_R15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -2325,27 +2478,27 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 16:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG2_Z16_15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z16_R15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG2_Z16_15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z16_R15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
             case 15:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG2_Z15_15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z15_R15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG2_Z15_15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z15_R15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
             case 14:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG2_Z14_15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z14_R15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG2_Z14_15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z14_R15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -2353,9 +2506,9 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 13:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG2_Z13_15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z13_R15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG2_Z13_15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z13_R15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -2363,9 +2516,9 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 12:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG2_Z12_15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z12_R15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG2_Z12_15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z12_R15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -2373,18 +2526,18 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 11:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG2_Z11_15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z11_R15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG2_Z11_15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z11_R15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
             case 10:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG2_Z10_15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z10_R15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG2_Z10_15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z10_R15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -2392,9 +2545,9 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 9:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG2_Z9_15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z9_R15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG2_Z9_15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z9_R15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -2402,9 +2555,9 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 8:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG2_Z8_15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z8_R15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG2_Z8_15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z8_R15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -2412,9 +2565,9 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 7:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG2_Z7_15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z7_R15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG2_Z7_15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z7_R15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -2422,9 +2575,9 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 6:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG2_Z6_15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z6_R15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG2_Z6_15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z6_R15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -2432,9 +2585,9 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 5:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG2_Z5_15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z5_R15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG2_Z5_15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z5_R15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -2442,9 +2595,9 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 4:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG2_Z4_15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z4_R15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG2_Z4_15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z4_R15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -2452,18 +2605,18 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 3:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG2_Z3_15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z3_R15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG2_Z3_15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z3_R15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
             case 2:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG2_Z2_15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z2_R15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG2_Z2_15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z2_R15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -2501,7 +2654,120 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
 #ifdef NR_LDPC_PROFILER_DETAIL
         start_meas(&p_profiler->bnProcPc);
 #endif
-        nrLDPC_bnProcPc(p_lut, p_procBuf, Z);
+            if(BG==1){
+
+            switch (Z)
+            {
+                case 384:
+                {
+                    nrLDPC_bnProcPc_BG1_Z384_R13_AVX2(p_procBuf->bnProcBuf,p_procBuf->bnProcBufRes,  p_procBuf->llrRes , p_procBuf->llrProcBuf );                                                                                                                                                                       
+                    break;
+                }
+                case 256:
+                {
+                    nrLDPC_bnProcPc_BG1_Z256_R13_AVX2(p_procBuf->bnProcBuf,p_procBuf->bnProcBufRes,  p_procBuf->llrRes , p_procBuf->llrProcBuf );                                                                                                                                                                       
+                    break;
+                }
+
+                case 192:
+                {
+                    nrLDPC_bnProcPc_BG1_Z192_R13_AVX2(p_procBuf->bnProcBuf,p_procBuf->bnProcBufRes,  p_procBuf->llrRes , p_procBuf->llrProcBuf );                                                                                                                                                                       
+                    break;
+                }
+
+                case 128:
+                {
+                    nrLDPC_bnProcPc_BG1_Z128_R13_AVX2(p_procBuf->bnProcBuf,p_procBuf->bnProcBufRes,  p_procBuf->llrRes , p_procBuf->llrProcBuf );                                                                                                                                                                       
+                    break;
+                }
+
+                case 96:
+                {
+                    nrLDPC_bnProcPc_BG1_Z96_R13_AVX2(p_procBuf->bnProcBuf,p_procBuf->bnProcBufRes,  p_procBuf->llrRes , p_procBuf->llrProcBuf );                                                                                                                                                                       
+                    break;
+                }
+
+                case 64:
+                {
+                    nrLDPC_bnProcPc_BG1_Z64_R13_AVX2(p_procBuf->bnProcBuf,p_procBuf->bnProcBufRes,  p_procBuf->llrRes , p_procBuf->llrProcBuf );                                                                                                                                                                       
+                    break;
+                }
+                case 48:
+                {
+                    nrLDPC_bnProcPc_BG1_Z48_R13_AVX2(p_procBuf->bnProcBuf,p_procBuf->bnProcBufRes,  p_procBuf->llrRes , p_procBuf->llrProcBuf );                                                                                                                                                                       
+                    break;
+                }
+                case 32:
+                {
+                    nrLDPC_bnProcPc_BG1_Z32_R13_AVX2(p_procBuf->bnProcBuf,p_procBuf->bnProcBufRes,  p_procBuf->llrRes , p_procBuf->llrProcBuf );                                                                                                                                                                       
+                    break;
+                }
+                default :
+                {
+                    nrLDPC_bnProcPc(p_lut, p_procBuf, Z);                                                                                                                                                                       
+                    break;
+                }
+               
+            }
+        }
+        else{
+            switch (Z)
+            {
+                case 384:
+                {
+                    nrLDPC_bnProcPc_BG2_Z384_R15_AVX2(p_procBuf->bnProcBuf,p_procBuf->bnProcBufRes,  p_procBuf->llrRes , p_procBuf->llrProcBuf );                                                                                                                                                                       
+                    break;
+                }
+                case 256:
+                {
+                    nrLDPC_bnProcPc_BG2_Z256_R15_AVX2(p_procBuf->bnProcBuf,p_procBuf->bnProcBufRes,  p_procBuf->llrRes , p_procBuf->llrProcBuf );                                                                                                                                                                       
+                    break;
+                }
+
+                case 192:
+                {
+                    nrLDPC_bnProcPc_BG2_Z192_R15_AVX2(p_procBuf->bnProcBuf,p_procBuf->bnProcBufRes,  p_procBuf->llrRes , p_procBuf->llrProcBuf );                                                                                                                                                                       
+                    break;
+                }
+
+                case 128:
+                {
+                    nrLDPC_bnProcPc_BG2_Z128_R15_AVX2(p_procBuf->bnProcBuf,p_procBuf->bnProcBufRes,  p_procBuf->llrRes , p_procBuf->llrProcBuf );                                                                                                                                                                       
+                    break;
+                }
+
+                case 96:
+                {
+                    nrLDPC_bnProcPc_BG2_Z96_R15_AVX2(p_procBuf->bnProcBuf,p_procBuf->bnProcBufRes,  p_procBuf->llrRes , p_procBuf->llrProcBuf );                                                                                                                                                                       
+                    break;
+                }
+
+                case 64:
+                {
+                    nrLDPC_bnProcPc_BG2_Z64_R15_AVX2(p_procBuf->bnProcBuf,p_procBuf->bnProcBufRes,  p_procBuf->llrRes , p_procBuf->llrProcBuf );                                                                                                                                                                       
+                    break;
+                }
+
+                case 48:
+                {
+                    nrLDPC_bnProcPc_BG2_Z48_R15_AVX2(p_procBuf->bnProcBuf,p_procBuf->bnProcBufRes,  p_procBuf->llrRes , p_procBuf->llrProcBuf );                                                                                                                                                                       
+                    break;
+                }
+
+                case 32:
+                {
+                    nrLDPC_bnProcPc_BG2_Z32_R15_AVX2(p_procBuf->bnProcBuf,p_procBuf->bnProcBufRes,  p_procBuf->llrRes , p_procBuf->llrProcBuf );                                                                                                                                                                       
+                    break;
+                }
+                default :
+                {
+                    nrLDPC_bnProcPc(p_lut, p_procBuf, Z);                                                                                                                                                                       
+                    break;
+                }
+               
+            }
+        }
+        
 #ifdef NR_LDPC_PROFILER_DETAIL
         stop_meas(&p_profiler->bnProcPc);
 #endif
@@ -2578,18 +2844,18 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 384:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG1_Z384_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z384_R13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG1_Z384_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z384_R13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
             case 352:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG1_Z352_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z352_R13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG1_Z352_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z352_R13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -2597,9 +2863,9 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 320:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG1_Z320_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z320_R13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG1_Z320_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z320_R13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -2607,9 +2873,9 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 288:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG1_Z288_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z288_R13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG1_Z288_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z288_R13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -2617,9 +2883,9 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 256:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG1_Z256_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z256_R13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG1_Z256_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z256_R13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -2627,9 +2893,9 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 240:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG1_Z240_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z240_R13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG1_Z240_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z240_R13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -2638,9 +2904,9 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             {
 
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG1_Z224_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z224_R13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG1_Z224_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z224_R13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -2648,9 +2914,9 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 208:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG1_Z208_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z208_R13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG1_Z208_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z208_R13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -2658,9 +2924,9 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 192:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG1_Z192_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z192_R13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG1_Z192_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z192_R13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -2668,9 +2934,9 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 176:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG1_Z176_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z176_R13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG1_Z176_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z176_R13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -2678,27 +2944,27 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 160:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG1_Z176_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z176_R13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG1_Z176_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z176_R13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
             case 144:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG1_Z144_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z144_R13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG1_Z144_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z144_R13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
             case 128:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG1_Z128_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z128_R13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG1_Z128_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z128_R13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -2706,9 +2972,9 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 120:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG1_Z120_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z120_R13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
             #else
-             nrLDPC_cnProc_BG1_Z120_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+             nrLDPC_cnProc_BG1_Z120_R13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -2716,9 +2982,9 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 112:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG1_Z112_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z112_R13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG1_Z112_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z112_R13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -2727,27 +2993,27 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 104:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG1_Z104_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z104_R13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG1_Z104_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z104_R13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
             case 96:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG1_Z96_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z96_R13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG1_Z96_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z96_R13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
             case 88:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG1_Z88_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z88_R13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG1_Z88_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z88_R13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -2755,9 +3021,9 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 80:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG1_Z80_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z80_R13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG1_Z80_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z80_R13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -2765,9 +3031,9 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 72:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG1_Z72_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z72_R13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG1_Z72_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z72_R13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -2775,9 +3041,9 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 64:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG1_Z64_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z64_R13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG1_Z64_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z64_R13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -2785,27 +3051,27 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 60:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG1_Z60_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z60_R13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG1_Z60_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z60_R13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
             case 56:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG1_Z56_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z56_R13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG1_Z56_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z56_R13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
             case 52:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG1_Z52_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z52_R13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG1_Z52_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z52_R13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -2813,9 +3079,9 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 48:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG1_Z48_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z48_R13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG1_Z48_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z48_R13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -2823,18 +3089,18 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 44:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG1_Z44_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z44_R13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG1_Z44_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z44_R13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
             case 40:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG1_Z40_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z40_R13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG1_Z40_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z40_R13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -2842,36 +3108,36 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 36:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG1_Z36_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z36_R13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG1_Z36_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z36_R13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
             case 32:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG1_Z32_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z32_R13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG1_Z32_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z32_R13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
             case 30:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG1_Z30_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z30_R13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG1_Z30_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z30_R13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
             case 28:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG1_Z28_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z28_R13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG1_Z28_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z28_R13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -2879,9 +3145,9 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 26:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG1_Z26_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z26_R13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG1_Z26_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z26_R13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -2889,9 +3155,9 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 24:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG1_Z24_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z24_R13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG1_Z24_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z24_R13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -2899,27 +3165,27 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 22:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG1_Z22_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z22_R13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG1_Z22_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z22_R13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
             case 20:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG1_Z20_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z20_R13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG1_Z20_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z20_R13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
             case 18:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG1_Z18_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z18_R13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG1_Z18_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z18_R13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -2927,27 +3193,27 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 16:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG1_Z16_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z16_R13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG1_Z16_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z16_R13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
             case 15:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG1_Z15_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z15_R13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG1_Z15_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z15_R13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
             case 14:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG1_Z14_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z14_R13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG1_Z14_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z14_R13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -2955,9 +3221,9 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 13:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG1_Z13_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z13_R13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG1_Z13_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z13_R13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -2965,9 +3231,9 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 12:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG1_Z12_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z12_R13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG1_Z12_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z12_R13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -2975,18 +3241,18 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 11:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG1_Z11_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z11_R13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG1_Z11_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z11_R13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
             case 10:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG1_Z10_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z10_R13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG1_Z10_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z10_R13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -2994,9 +3260,9 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 9:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG1_Z9_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z9_R13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG1_Z9_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z9_R13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -3004,9 +3270,9 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 8:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG1_Z8_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z8_R13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG1_Z8_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z8_R13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -3014,9 +3280,9 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 7:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG1_Z7_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z7_R13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG1_Z7_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z7_R13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -3024,9 +3290,9 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 6:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG1_Z6_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z6_R13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG1_Z6_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z6_R13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -3034,9 +3300,9 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 5:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG1_Z5_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z5_R13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG1_Z5_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z5_R13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -3044,9 +3310,9 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 4:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG1_Z4_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z4_R13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG1_Z4_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z4_R13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -3054,18 +3320,18 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 3:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG1_Z3_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z3_R13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG1_Z3_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z3_R13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
             case 2:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG1_Z2_13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z2_R13_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG1_Z2_13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG1_Z2_R13_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -3078,18 +3344,18 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 384:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG2_Z384_15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z384_R15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG2_Z384_15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z384_R15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
             case 352:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG2_Z352_15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z352_R15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG2_Z352_15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z352_R15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -3097,9 +3363,9 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 320:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG2_Z320_15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z320_R15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG2_Z320_15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z320_R15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -3107,9 +3373,9 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 288:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG2_Z288_15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z288_R15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG2_Z288_15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z288_R15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -3117,9 +3383,9 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 256:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG2_Z256_15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z256_R15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG2_Z256_15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z256_R15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -3127,9 +3393,9 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 240:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG2_Z240_15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z240_R15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
             #else
-             nrLDPC_cnProc_BG2_Z240_15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+             nrLDPC_cnProc_BG2_Z240_R15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -3138,9 +3404,9 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             {
 
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG2_Z224_15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z224_R15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG2_Z224_15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z224_R15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -3148,9 +3414,9 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 208:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG2_Z208_15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z208_R15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG2_Z208_15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z208_R15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -3158,9 +3424,9 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 192:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG2_Z192_15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z192_R15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG2_Z192_15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z192_R15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -3168,9 +3434,9 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 176:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG2_Z176_15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z176_R15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG2_Z176_15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z176_R15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -3178,27 +3444,27 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 160:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG2_Z176_15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z176_R15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG2_Z176_15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z176_R15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
             case 144:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG2_Z144_15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z144_R15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG2_Z144_15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z144_R15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
             case 128:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG2_Z128_15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z128_R15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                 nrLDPC_cnProc_BG2_Z128_15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                 nrLDPC_cnProc_BG2_Z128_R15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -3206,9 +3472,9 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 120:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG2_Z120_15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z120_R15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
             #else
-             nrLDPC_cnProc_BG2_Z120_15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+             nrLDPC_cnProc_BG2_Z120_R15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -3216,9 +3482,9 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 112:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG2_Z112_15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z112_R15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG2_Z112_15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z112_R15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -3227,27 +3493,27 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 104:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG2_Z104_15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z104_R15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG2_Z104_15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z104_R15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
             case 96:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG2_Z96_15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z96_R15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG2_Z96_15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z96_R15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
             case 88:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG2_Z88_15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z88_R15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG2_Z88_15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z88_R15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -3255,9 +3521,9 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 80:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG2_Z80_15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z80_R15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG2_Z80_15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z80_R15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -3265,9 +3531,9 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 72:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG2_Z72_15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z72_R15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG2_Z72_15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z72_R15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -3275,9 +3541,9 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 64:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG2_Z64_15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z64_R15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG2_Z64_15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z64_R15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -3285,27 +3551,27 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 60:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG2_Z60_15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z60_R15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG2_Z60_15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z60_R15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
             case 56:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG2_Z56_15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z56_R15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG2_Z56_15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z56_R15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
             case 52:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG2_Z52_15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z52_R15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG2_Z52_15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z52_R15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -3313,9 +3579,9 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 48:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG2_Z48_15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z48_R15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG2_Z48_15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z48_R15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -3323,18 +3589,18 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 44:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG2_Z44_15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z44_R15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG2_Z44_15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z44_R15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
             case 40:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG2_Z40_15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z40_R15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG2_Z40_15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z40_R15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -3342,36 +3608,36 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 36:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG2_Z36_15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z36_R15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG2_Z36_15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z36_R15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
             case 32:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG2_Z32_15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z32_R15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG2_Z32_15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z32_R15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
             case 30:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG2_Z30_15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z30_R15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG2_Z30_15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z30_R15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
             case 28:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG2_Z28_15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z28_R15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG2_Z28_15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z28_R15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -3379,9 +3645,9 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 26:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG2_Z26_15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z26_R15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG2_Z26_15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z26_R15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -3389,9 +3655,9 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 24:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG2_Z24_15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z24_R15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG2_Z24_15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z24_R15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -3399,27 +3665,27 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 22:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG2_Z22_15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z22_R15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG2_Z22_15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z22_R15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
             case 20:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG2_Z20_15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z20_R15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG2_Z20_15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z20_R15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
             case 18:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG2_Z18_15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z18_R15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG2_Z18_15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z18_R15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -3427,27 +3693,27 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 16:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG2_Z16_15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z16_R15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG2_Z16_15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z16_R15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
             case 15:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG2_Z15_15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z15_R15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG2_Z15_15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z15_R15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
             case 14:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG2_Z14_15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z14_R15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG2_Z14_15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z14_R15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -3455,9 +3721,9 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 13:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG2_Z13_15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z13_R15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG2_Z13_15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z13_R15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -3465,9 +3731,9 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 12:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG2_Z12_15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z12_R15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG2_Z12_15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z12_R15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -3475,18 +3741,18 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 11:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG2_Z11_15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z11_R15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG2_Z11_15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z11_R15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
             case 10:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG2_Z10_15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z10_R15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG2_Z10_15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z10_R15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -3494,9 +3760,9 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 9:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG2_Z9_15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z9_R15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG2_Z9_15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z9_R15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -3504,9 +3770,9 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 8:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG2_Z8_15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z8_R15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG2_Z8_15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z8_R15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -3514,9 +3780,9 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 7:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG2_Z7_15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z7_R15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG2_Z7_15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z7_R15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -3524,9 +3790,9 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 6:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG2_Z6_15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z6_R15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG2_Z6_15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z6_R15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -3534,9 +3800,9 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 5:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG2_Z5_15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z5_R15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG2_Z5_15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z5_R15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -3544,9 +3810,9 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 4:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG2_Z4_15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z4_R15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG2_Z4_15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z4_R15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -3554,18 +3820,18 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
             case 3:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG2_Z3_15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z3_R15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG2_Z3_15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z3_R15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
             case 2:
             {
                 #ifdef __AVX512BW__
-                nrLDPC_cnProc_BG2_Z2_15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z2_R15_AVX512(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #else
-                nrLDPC_cnProc_BG2_Z2_15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
+                nrLDPC_cnProc_BG2_Z2_R15_AVX2(p_procBuf->cnProcBuf,p_procBuf->cnProcBufRes);
                 #endif                                                                                                                                                                        
                 break;
             }
@@ -3619,7 +3885,122 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
 #ifdef NR_LDPC_PROFILER_DETAIL
         start_meas(&p_profiler->bnProc);
 #endif
-        nrLDPC_bnProc(p_lut, p_procBuf, Z);
+
+        if(BG==1){
+
+            switch (Z)
+            {
+                case 384:
+                {
+                    nrLDPC_bnProcPc_BG1_Z384_R13_AVX2(p_procBuf->bnProcBuf,p_procBuf->bnProcBufRes,  p_procBuf->llrRes , p_procBuf->llrProcBuf );                                                                                                                                                                       
+                    break;
+                }
+                case 256:
+                {
+                    nrLDPC_bnProcPc_BG1_Z256_R13_AVX2(p_procBuf->bnProcBuf,p_procBuf->bnProcBufRes,  p_procBuf->llrRes , p_procBuf->llrProcBuf );                                                                                                                                                                       
+                    break;
+                }
+
+                case 192:
+                {
+                    nrLDPC_bnProcPc_BG1_Z192_R13_AVX2(p_procBuf->bnProcBuf,p_procBuf->bnProcBufRes,  p_procBuf->llrRes , p_procBuf->llrProcBuf );                                                                                                                                                                       
+                    break;
+                }
+
+                case 128:
+                {
+                    nrLDPC_bnProcPc_BG1_Z128_R13_AVX2(p_procBuf->bnProcBuf,p_procBuf->bnProcBufRes,  p_procBuf->llrRes , p_procBuf->llrProcBuf );                                                                                                                                                                       
+                    break;
+                }
+
+                case 96:
+                {
+                    nrLDPC_bnProcPc_BG1_Z96_R13_AVX2(p_procBuf->bnProcBuf,p_procBuf->bnProcBufRes,  p_procBuf->llrRes , p_procBuf->llrProcBuf );                                                                                                                                                                       
+                    break;
+                }
+
+                case 64:
+                {
+                    nrLDPC_bnProcPc_BG1_Z64_R13_AVX2(p_procBuf->bnProcBuf,p_procBuf->bnProcBufRes,  p_procBuf->llrRes , p_procBuf->llrProcBuf );                                                                                                                                                                       
+                    break;
+                }
+                case 48:
+                {
+                    nrLDPC_bnProcPc_BG1_Z48_R13_AVX2(p_procBuf->bnProcBuf,p_procBuf->bnProcBufRes,  p_procBuf->llrRes , p_procBuf->llrProcBuf );                                                                                                                                                                       
+                    break;
+                }
+                case 32:
+                {
+                    nrLDPC_bnProcPc_BG1_Z32_R13_AVX2(p_procBuf->bnProcBuf,p_procBuf->bnProcBufRes,  p_procBuf->llrRes , p_procBuf->llrProcBuf );                                                                                                                                                                       
+                    break;
+                }
+                default :
+                {
+                    nrLDPC_bnProcPc(p_lut, p_procBuf, Z);                                                                                                                                                                       
+                    break;
+                }
+               
+            }
+        }
+        else{
+            switch (Z)
+            {
+                case 384:
+                {
+                    nrLDPC_bnProcPc_BG2_Z384_R15_AVX2(p_procBuf->bnProcBuf,p_procBuf->bnProcBufRes,  p_procBuf->llrRes , p_procBuf->llrProcBuf );                                                                                                                                                                       
+                    break;
+                }
+                case 256:
+                {
+                    nrLDPC_bnProcPc_BG2_Z256_R15_AVX2(p_procBuf->bnProcBuf,p_procBuf->bnProcBufRes,  p_procBuf->llrRes , p_procBuf->llrProcBuf );                                                                                                                                                                       
+                    break;
+                }
+
+                case 192:
+                {
+                    nrLDPC_bnProcPc_BG2_Z192_R15_AVX2(p_procBuf->bnProcBuf,p_procBuf->bnProcBufRes,  p_procBuf->llrRes , p_procBuf->llrProcBuf );                                                                                                                                                                       
+                    break;
+                }
+
+                case 128:
+                {
+                    nrLDPC_bnProcPc_BG2_Z128_R15_AVX2(p_procBuf->bnProcBuf,p_procBuf->bnProcBufRes,  p_procBuf->llrRes , p_procBuf->llrProcBuf );                                                                                                                                                                       
+                    break;
+                }
+
+                case 96:
+                {
+                    nrLDPC_bnProcPc_BG2_Z96_R15_AVX2(p_procBuf->bnProcBuf,p_procBuf->bnProcBufRes,  p_procBuf->llrRes , p_procBuf->llrProcBuf );                                                                                                                                                                       
+                    break;
+                }
+
+                case 64:
+                {
+                    nrLDPC_bnProcPc_BG2_Z64_R15_AVX2(p_procBuf->bnProcBuf,p_procBuf->bnProcBufRes,  p_procBuf->llrRes , p_procBuf->llrProcBuf );                                                                                                                                                                       
+                    break;
+                }
+
+                case 48:
+                {
+                    nrLDPC_bnProcPc_BG2_Z48_R15_AVX2(p_procBuf->bnProcBuf,p_procBuf->bnProcBufRes,  p_procBuf->llrRes , p_procBuf->llrProcBuf );                                                                                                                                                                       
+                    break;
+                }
+
+                case 32:
+                {
+                    nrLDPC_bnProcPc_BG2_Z32_R15_AVX2(p_procBuf->bnProcBuf,p_procBuf->bnProcBufRes,  p_procBuf->llrRes , p_procBuf->llrProcBuf );                                                                                                                                                                       
+                    break;
+                }
+                default :
+                {
+                    nrLDPC_bnProcPc(p_lut, p_procBuf, Z);                                                                                                                                                                       
+                    break;
+                }
+               
+            }
+        }
+        
+
 #ifdef NR_LDPC_PROFILER_DETAIL
         stop_meas(&p_profiler->bnProc);
 #endif
@@ -3708,3 +4089,4 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
 
 
 
+
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_decoder.c.full b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_decoder.c.full
new file mode 100644
index 0000000000..34bfdc2fb3
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_decoder.c.full
@@ -0,0 +1,534 @@
+
+/*
+ * 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
+ */
+
+/*!\file nrLDPC_decoder.c
+ * \brief Defines the LDPC decoder
+ * \author Sebastian Wagner (TCL Communications) Email: <mailto:sebastian.wagner@tcl.com>
+ * \date 30-09-2019
+ * \version 2.0
+ * \note
+ * \warning
+ */
+
+
+#include <stdint.h>
+#include <immintrin.h>
+#include "nrLDPCdecoder_defs.h"
+#include "nrLDPC_types.h"
+#include "nrLDPC_init.h"
+#include "nrLDPC_mPass.h"
+#include "nrLDPC_cnProc.h"
+#include "nrLDPC_bnProc.h"
+
+
+#define NR_LDPC_ENABLE_PARITY_CHECK
+#define NR_LDPC_PROFILER_DETAIL
+
+#ifdef NR_LDPC_DEBUG_MODE
+#include "nrLDPC_tools/nrLDPC_debug.h"
+#endif
+
+static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDPC_procBuf* p_procBuf, uint32_t numLLR, t_nrLDPC_lut* p_lut, t_nrLDPC_dec_params* p_decParams, t_nrLDPC_time_stats* p_profiler);
+
+int32_t nrLDPC_decod(t_nrLDPC_dec_params* p_decParams, int8_t* p_llr, int8_t* p_out, t_nrLDPC_procBuf* p_procBuf, t_nrLDPC_time_stats* p_profiler)
+{
+    uint32_t numLLR;
+    uint32_t numIter = 0;
+    t_nrLDPC_lut lut;
+    t_nrLDPC_lut* p_lut = &lut;
+
+    //printf("p_procBuf->cnProcBuf = %p\n", p_procBuf->cnProcBuf);
+
+    // Initialize decoder core(s) with correct LUTs
+    numLLR = nrLDPC_init(p_decParams, p_lut);
+
+    // Launch LDPC decoder core for one segment
+    numIter = nrLDPC_decoder_core(p_llr, p_out, p_procBuf, numLLR, p_lut, p_decParams, p_profiler);
+
+    return numIter;
+}
+
+/**
+   \brief Performs LDPC decoding of one code block
+   \param p_llr Input LLRs
+   \param p_out Output vector
+   \param numLLR Number of LLRs
+   \param p_lut Pointer to decoder LUTs
+   \param p_decParams LDPC decoder parameters
+   \param p_profiler LDPC profiler statistics
+*/
+static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDPC_procBuf* p_procBuf, uint32_t numLLR, t_nrLDPC_lut* p_lut, t_nrLDPC_dec_params* p_decParams, t_nrLDPC_time_stats* p_profiler)
+{
+    uint16_t Z          = p_decParams->Z;
+    uint8_t  BG         = p_decParams->BG;
+    uint8_t  numMaxIter = p_decParams->numMaxIter;
+    e_nrLDPC_outMode outMode = p_decParams->outMode;
+
+    // Minimum number of iterations is 1
+    // 0 iterations means hard-decision on input LLRs
+    uint32_t i = 1;
+    // Initialize with parity check fail != 0
+    int32_t pcRes = 1;
+    int8_t* p_llrOut;
+
+    if (outMode == nrLDPC_outMode_LLRINT8)
+    {
+        p_llrOut = p_out;
+    }
+    else
+    {
+        // Use LLR processing buffer as temporary output buffer
+        p_llrOut = p_procBuf->llrProcBuf;
+        // Clear llrProcBuf
+        memset(p_llrOut,0, NR_LDPC_MAX_NUM_LLR*sizeof(int8_t));
+    }
+
+
+    // Initialization
+#ifdef NR_LDPC_PROFILER_DETAIL
+    start_meas(&p_profiler->llr2llrProcBuf);
+#endif
+    nrLDPC_llr2llrProcBuf(p_lut, p_llr, p_procBuf, Z, BG);
+#ifdef NR_LDPC_PROFILER_DETAIL
+    stop_meas(&p_profiler->llr2llrProcBuf);
+#endif
+
+#ifdef NR_LDPC_DEBUG_MODE
+    nrLDPC_debug_initBuffer2File(nrLDPC_buffers_LLR_PROC);
+    nrLDPC_debug_writeBuffer2File(nrLDPC_buffers_LLR_PROC, p_procBuf);
+#endif
+
+#ifdef NR_LDPC_PROFILER_DETAIL
+    start_meas(&p_profiler->llr2CnProcBuf);
+#endif
+    if (BG == 1)
+    {
+        nrLDPC_llr2CnProcBuf_BG1(p_lut, p_llr, p_procBuf, Z);
+    }
+    else
+    {
+        nrLDPC_llr2CnProcBuf_BG2(p_lut, p_llr, p_procBuf, Z);
+    }
+#ifdef NR_LDPC_PROFILER_DETAIL
+    stop_meas(&p_profiler->llr2CnProcBuf);
+#endif
+
+#ifdef NR_LDPC_DEBUG_MODE
+    nrLDPC_debug_initBuffer2File(nrLDPC_buffers_CN_PROC);
+    nrLDPC_debug_writeBuffer2File(nrLDPC_buffers_CN_PROC, p_procBuf);
+#endif
+
+    // First iteration
+
+    // CN processing
+#ifdef NR_LDPC_PROFILER_DETAIL
+    start_meas(&p_profiler->cnProc);
+#endif
+        if (BG == 1)
+        {
+            #ifdef __AVX512BW__
+            nrLDPC_cnProc_BG1_AVX512(p_lut, p_procBuf, Z);
+            #else
+            nrLDPC_cnProc_BG1(p_lut, p_procBuf, Z);
+            #endif
+        }
+        else
+        {
+            #ifdef __AVX512BW__
+            nrLDPC_cnProc_BG2_AVX512(p_lut, p_procBuf, Z);
+            #else
+            nrLDPC_cnProc_BG2(p_lut, p_procBuf, Z);
+            #endif
+        }
+#ifdef NR_LDPC_PROFILER_DETAIL
+    stop_meas(&p_profiler->cnProc);
+#endif
+
+#ifdef NR_LDPC_DEBUG_MODE
+    nrLDPC_debug_initBuffer2File(nrLDPC_buffers_CN_PROC_RES);
+    nrLDPC_debug_writeBuffer2File(nrLDPC_buffers_CN_PROC_RES, p_procBuf);
+#endif
+
+#ifdef NR_LDPC_PROFILER_DETAIL
+    start_meas(&p_profiler->cn2bnProcBuf);
+#endif
+    if (BG == 1)
+    {
+        nrLDPC_cn2bnProcBuf_BG1(p_lut, p_procBuf, Z);
+    }
+    else
+    {
+        nrLDPC_cn2bnProcBuf_BG2(p_lut, p_procBuf, Z);
+    }
+#ifdef NR_LDPC_PROFILER_DETAIL
+    stop_meas(&p_profiler->cn2bnProcBuf);
+#endif
+
+#ifdef NR_LDPC_DEBUG_MODE
+    nrLDPC_debug_initBuffer2File(nrLDPC_buffers_BN_PROC);
+    nrLDPC_debug_writeBuffer2File(nrLDPC_buffers_BN_PROC, p_procBuf);
+#endif
+
+    // BN processing
+#ifdef NR_LDPC_PROFILER_DETAIL
+    start_meas(&p_profiler->bnProcPc);
+#endif
+
+nrLDPC_bnProcPc(p_lut, p_procBuf, Z);
+
+
+#ifdef NR_LDPC_PROFILER_DETAIL
+    stop_meas(&p_profiler->bnProcPc);
+#endif
+
+#ifdef NR_LDPC_DEBUG_MODE
+    nrLDPC_debug_initBuffer2File(nrLDPC_buffers_LLR_RES);
+    nrLDPC_debug_writeBuffer2File(nrLDPC_buffers_LLR_RES, p_procBuf);
+#endif
+
+#ifdef NR_LDPC_PROFILER_DETAIL
+    start_meas(&p_profiler->bnProc);
+#endif
+    nrLDPC_bnProc(p_lut, p_procBuf, Z);
+
+#ifdef NR_LDPC_PROFILER_DETAIL
+    stop_meas(&p_profiler->bnProc);
+#endif
+
+#ifdef NR_LDPC_DEBUG_MODE
+    nrLDPC_debug_initBuffer2File(nrLDPC_buffers_BN_PROC_RES);
+    nrLDPC_debug_writeBuffer2File(nrLDPC_buffers_BN_PROC_RES, p_procBuf);
+#endif
+
+    // BN results to CN processing buffer
+#ifdef NR_LDPC_PROFILER_DETAIL
+    start_meas(&p_profiler->bn2cnProcBuf);
+#endif
+    if (BG == 1)
+    {
+        nrLDPC_bn2cnProcBuf_BG1(p_lut, p_procBuf, Z);
+    }
+    else
+    {
+        nrLDPC_bn2cnProcBuf_BG2(p_lut, p_procBuf, Z);
+    }
+#ifdef NR_LDPC_PROFILER_DETAIL
+    stop_meas(&p_profiler->bn2cnProcBuf);
+#endif
+
+#ifdef NR_LDPC_DEBUG_MODE
+    nrLDPC_debug_writeBuffer2File(nrLDPC_buffers_CN_PROC, p_procBuf);
+#endif
+
+    // Parity Check not necessary here since it will fail
+    // because first 2 cols/BNs in BG are punctured and cannot be
+    // estimated after only one iteration
+
+    // First iteration finished
+
+    while ( (i < (numMaxIter-1)) && (pcRes != 0) )
+    {
+        // Increase iteration counter
+        i++;
+
+        // CN processing
+#ifdef NR_LDPC_PROFILER_DETAIL
+        start_meas(&p_profiler->cnProc);
+
+#endif
+        if (BG == 1)
+        {
+            #ifdef __AVX512BW__
+            nrLDPC_cnProc_BG1_AVX512(p_lut, p_procBuf, Z);
+            #else
+            nrLDPC_cnProc_BG1(p_lut, p_procBuf, Z);
+            #endif
+        }
+        else
+        {
+            #ifdef __AVX512BW__
+            nrLDPC_cnProc_BG2_AVX512(p_lut, p_procBuf, Z);
+            #else
+            nrLDPC_cnProc_BG2(p_lut, p_procBuf, Z);
+            #endif
+        }
+#ifdef NR_LDPC_PROFILER_DETAIL
+        stop_meas(&p_profiler->cnProc);
+#endif
+
+#ifdef NR_LDPC_DEBUG_MODE
+        nrLDPC_debug_writeBuffer2File(nrLDPC_buffers_CN_PROC_RES, p_procBuf);
+#endif
+
+        // Send CN results back to BNs
+#ifdef NR_LDPC_PROFILER_DETAIL
+        start_meas(&p_profiler->cn2bnProcBuf);
+#endif
+        if (BG == 1)
+        {
+            nrLDPC_cn2bnProcBuf_BG1(p_lut, p_procBuf, Z);
+        }
+        else
+        {
+            nrLDPC_cn2bnProcBuf_BG2(p_lut, p_procBuf, Z);
+        }
+#ifdef NR_LDPC_PROFILER_DETAIL
+        stop_meas(&p_profiler->cn2bnProcBuf);
+#endif
+
+#ifdef NR_LDPC_DEBUG_MODE
+        nrLDPC_debug_writeBuffer2File(nrLDPC_buffers_BN_PROC, p_procBuf);
+#endif
+
+        // BN Processing
+#ifdef NR_LDPC_PROFILER_DETAIL
+        start_meas(&p_profiler->bnProcPc);
+#endif
+        nrLDPC_bnProcPc(p_lut, p_procBuf, Z);
+
+#ifdef NR_LDPC_PROFILER_DETAIL
+        stop_meas(&p_profiler->bnProcPc);
+#endif
+
+#ifdef NR_LDPC_DEBUG_MODE
+        nrLDPC_debug_writeBuffer2File(nrLDPC_buffers_LLR_RES, p_procBuf);
+#endif
+
+#ifdef NR_LDPC_PROFILER_DETAIL
+        start_meas(&p_profiler->bnProc);
+#endif
+       nrLDPC_bnProc(p_lut, p_procBuf, Z);
+
+#ifdef NR_LDPC_PROFILER_DETAIL
+        stop_meas(&p_profiler->bnProc);
+#endif
+
+#ifdef NR_LDPC_DEBUG_MODE
+        nrLDPC_debug_writeBuffer2File(nrLDPC_buffers_BN_PROC_RES, p_procBuf);
+#endif
+
+        // BN results to CN processing buffer
+#ifdef NR_LDPC_PROFILER_DETAIL
+        start_meas(&p_profiler->bn2cnProcBuf);
+#endif
+        if (BG == 1)
+        {
+            nrLDPC_bn2cnProcBuf_BG1(p_lut, p_procBuf, Z);
+        }
+        else
+        {
+            nrLDPC_bn2cnProcBuf_BG2(p_lut, p_procBuf, Z);
+        }
+#ifdef NR_LDPC_PROFILER_DETAIL
+        stop_meas(&p_profiler->bn2cnProcBuf);
+#endif
+
+#ifdef NR_LDPC_DEBUG_MODE
+        nrLDPC_debug_writeBuffer2File(nrLDPC_buffers_CN_PROC, p_procBuf);
+#endif
+
+        // Parity Check
+#ifdef NR_LDPC_ENABLE_PARITY_CHECK
+#ifdef NR_LDPC_PROFILER_DETAIL
+        start_meas(&p_profiler->cnProcPc);
+#endif
+        if (BG == 1)
+        {
+            pcRes = nrLDPC_cnProcPc_BG1(p_lut, p_procBuf, Z);
+        }
+        else
+        {
+            pcRes = nrLDPC_cnProcPc_BG2(p_lut, p_procBuf, Z);
+        }
+#ifdef NR_LDPC_PROFILER_DETAIL
+        stop_meas(&p_profiler->cnProcPc);
+#endif
+#endif
+    }
+
+    // Last iteration
+    if ( (i < numMaxIter) && (pcRes != 0) )
+    {
+        // Increase iteration counter
+        i++;
+
+        // CN processing
+#ifdef NR_LDPC_PROFILER_DETAIL
+        start_meas(&p_profiler->cnProc);
+#endif
+        if (BG == 1)
+        {
+            #ifdef __AVX512BW__
+            nrLDPC_cnProc_BG1_AVX512(p_lut, p_procBuf, Z);
+            #else
+            nrLDPC_cnProc_BG1(p_lut, p_procBuf, Z);
+            #endif
+        }
+        else
+        {
+            #ifdef __AVX512BW__
+            nrLDPC_cnProc_BG2_AVX512(p_lut, p_procBuf, Z);
+            #else
+            nrLDPC_cnProc_BG2(p_lut, p_procBuf, Z);
+            #endif
+        }
+#ifdef NR_LDPC_PROFILER_DETAIL
+        stop_meas(&p_profiler->cnProc);
+#endif
+
+#ifdef NR_LDPC_DEBUG_MODE
+        nrLDPC_debug_writeBuffer2File(nrLDPC_buffers_CN_PROC_RES, p_procBuf);
+#endif
+
+        // Send CN results back to BNs
+#ifdef NR_LDPC_PROFILER_DETAIL
+        start_meas(&p_profiler->cn2bnProcBuf);
+#endif
+        if (BG == 1)
+        {
+            nrLDPC_cn2bnProcBuf_BG1(p_lut, p_procBuf, Z);
+        }
+        else
+        {
+            nrLDPC_cn2bnProcBuf_BG2(p_lut, p_procBuf, Z);
+        }
+#ifdef NR_LDPC_PROFILER_DETAIL
+        stop_meas(&p_profiler->cn2bnProcBuf);
+#endif
+
+#ifdef NR_LDPC_DEBUG_MODE
+        nrLDPC_debug_writeBuffer2File(nrLDPC_buffers_BN_PROC, p_procBuf);
+#endif
+
+        // BN Processing
+#ifdef NR_LDPC_PROFILER_DETAIL
+        start_meas(&p_profiler->bnProcPc);
+#endif
+    nrLDPC_bnProcPc(p_lut, p_procBuf, Z);
+
+
+
+#ifdef NR_LDPC_PROFILER_DETAIL
+        stop_meas(&p_profiler->bnProcPc);
+#endif
+
+#ifdef NR_LDPC_DEBUG_MODE
+        nrLDPC_debug_writeBuffer2File(nrLDPC_buffers_LLR_RES, p_procBuf);
+#endif
+
+        // If parity check not enabled, no need to send the BN proc results
+        // back to CNs
+#ifdef NR_LDPC_ENABLE_PARITY_CHECK
+#ifdef NR_LDPC_PROFILER_DETAIL
+        start_meas(&p_profiler->bnProc);
+#endif
+        nrLDPC_bnProc(p_lut, p_procBuf, Z);
+
+
+#ifdef NR_LDPC_PROFILER_DETAIL
+        stop_meas(&p_profiler->bnProc);
+#endif
+
+#ifdef NR_LDPC_DEBUG_MODE
+        nrLDPC_debug_writeBuffer2File(nrLDPC_buffers_BN_PROC_RES, p_procBuf);
+#endif
+
+        // BN results to CN processing buffer
+#ifdef NR_LDPC_PROFILER_DETAIL
+        start_meas(&p_profiler->bn2cnProcBuf);
+#endif
+        if (BG == 1)
+        {
+            nrLDPC_bn2cnProcBuf_BG1(p_lut, p_procBuf, Z);
+        }
+        else
+        {
+            nrLDPC_bn2cnProcBuf_BG2(p_lut, p_procBuf, Z);
+        }
+#ifdef NR_LDPC_PROFILER_DETAIL
+        stop_meas(&p_profiler->bn2cnProcBuf);
+#endif
+
+#ifdef NR_LDPC_DEBUG_MODE
+        nrLDPC_debug_writeBuffer2File(nrLDPC_buffers_CN_PROC, p_procBuf);
+#endif
+
+        // Parity Check
+#ifdef NR_LDPC_PROFILER_DETAIL
+        start_meas(&p_profiler->cnProcPc);
+#endif
+        if (BG == 1)
+        {
+            pcRes = nrLDPC_cnProcPc_BG1(p_lut, p_procBuf, Z);
+        }
+        else
+        {
+            pcRes = nrLDPC_cnProcPc_BG2(p_lut, p_procBuf, Z);
+        }
+#ifdef NR_LDPC_PROFILER_DETAIL
+        stop_meas(&p_profiler->cnProcPc);
+#endif
+#endif
+    }
+
+    // If maximum number of iterations reached an PC still fails increase number of iterations
+    // Thus, i > numMaxIter indicates that PC has failed
+
+#ifdef NR_LDPC_ENABLE_PARITY_CHECK
+    if (pcRes != 0)
+    {
+        i++;
+    }
+#endif
+
+    // Assign results from processing buffer to output
+#ifdef NR_LDPC_PROFILER_DETAIL
+    start_meas(&p_profiler->llrRes2llrOut);
+#endif
+    nrLDPC_llrRes2llrOut(p_lut, p_llrOut, p_procBuf, Z, BG);
+#ifdef NR_LDPC_PROFILER_DETAIL
+    stop_meas(&p_profiler->llrRes2llrOut);
+#endif
+
+    // Hard-decision
+#ifdef NR_LDPC_PROFILER_DETAIL
+    start_meas(&p_profiler->llr2bit);
+#endif
+    if (outMode == nrLDPC_outMode_BIT)
+    {
+        nrLDPC_llr2bitPacked(p_out, p_llrOut, numLLR);
+    }
+    else if (outMode == nrLDPC_outMode_BITINT8)
+    {
+        nrLDPC_llr2bit(p_out, p_llrOut, numLLR);
+    }
+
+#ifdef NR_LDPC_PROFILER_DETAIL
+    stop_meas(&p_profiler->llr2bit);
+#endif
+
+    return i;
+}
+
+
+
+
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_mPass.h b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_mPass.h
index 8ebadd33f6..00841b2784 100644
--- a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_mPass.h
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_mPass.h
@@ -29,7 +29,7 @@
 
 #include <string.h>
 #include "nrLDPCdecoder_defs.h"
-#include <omp.h>
+//#include <omp.h>
 /**
    \brief Circular memcpy1
                 |<- rem->|<- circular shift ->|
@@ -1026,7 +1026,7 @@ static inline void nrLDPC_bn2cnProcBuf_BG1(t_nrLDPC_lut* p_lut, t_nrLDPC_procBuf
     // CN group with 3 BNs
 
     bitOffsetInGroup = lut_numCnInCnGroups_BG1_R13[0]*NR_LDPC_ZMAX;
-   
+    #pragma omp simd
     for (j=0;j<2; j++)
     {
         p_cnProcBuf = &cnProcBuf[lut_startAddrCnGroups[0] + j*bitOffsetInGroup];
@@ -1037,11 +1037,11 @@ static inline void nrLDPC_bn2cnProcBuf_BG1(t_nrLDPC_lut* p_lut, t_nrLDPC_procBuf
     // CN group with 4 BNs
 
     bitOffsetInGroup = lut_numCnInCnGroups_BG1_R13[1]*NR_LDPC_ZMAX;
-  
+  // #pragma omp simd
     for (j=0; j<3; j++)
     {
         p_cnProcBuf = &cnProcBuf[lut_startAddrCnGroups[1] + j*bitOffsetInGroup];
-       
+        #pragma omp simd
         for (i=0; i<lut_numCnInCnGroups[1]; i++)
         {
             idxBn = lut_startAddrBnProcBuf_CNG4[j][i] + lut_bnPosBnProcBuf_CNG4[j][i]*Z;
@@ -1053,11 +1053,11 @@ static inline void nrLDPC_bn2cnProcBuf_BG1(t_nrLDPC_lut* p_lut, t_nrLDPC_procBuf
     // CN group with 5 BNs
 
     bitOffsetInGroup = lut_numCnInCnGroups_BG1_R13[2]*NR_LDPC_ZMAX;
-
+//    #pragma omp simd
     for (j=0; j<4; j++)
     {
         p_cnProcBuf = &cnProcBuf[lut_startAddrCnGroups[2] + j*bitOffsetInGroup];
-        
+        #pragma omp simd
         for (i=0; i<lut_numCnInCnGroups[2]; i++)
         {
             idxBn = lut_startAddrBnProcBuf_CNG5[j][i] + lut_bnPosBnProcBuf_CNG5[j][i]*Z;
@@ -1070,11 +1070,11 @@ static inline void nrLDPC_bn2cnProcBuf_BG1(t_nrLDPC_lut* p_lut, t_nrLDPC_procBuf
     // CN group with 6 BNs
 
     bitOffsetInGroup = lut_numCnInCnGroups_BG1_R13[3]*NR_LDPC_ZMAX;
-   
+    //#pragma omp simd
     for (j=0; j<5; j++)
     {
         p_cnProcBuf = &cnProcBuf[lut_startAddrCnGroups[3] + j*bitOffsetInGroup];
-     
+        #pragma omp simd
         for (i=0; i<lut_numCnInCnGroups[3]; i++)
         {
             idxBn = lut_startAddrBnProcBuf_CNG6[j][i] + lut_bnPosBnProcBuf_CNG6[j][i]*Z;
@@ -1087,11 +1087,12 @@ static inline void nrLDPC_bn2cnProcBuf_BG1(t_nrLDPC_lut* p_lut, t_nrLDPC_procBuf
     // CN group with 7 BNs
 
     bitOffsetInGroup = lut_numCnInCnGroups_BG1_R13[4]*NR_LDPC_ZMAX;
-   
+    //#pragma omp simd
     for (j=0; j<6; j++)
     {
         p_cnProcBuf = &cnProcBuf[lut_startAddrCnGroups[4] + j*bitOffsetInGroup];
 
+        #pragma omp simd
         for (i=0; i<lut_numCnInCnGroups[4]; i++)
         {
             idxBn = lut_startAddrBnProcBuf_CNG7[j][i] + lut_bnPosBnProcBuf_CNG7[j][i]*Z;
@@ -1104,6 +1105,7 @@ static inline void nrLDPC_bn2cnProcBuf_BG1(t_nrLDPC_lut* p_lut, t_nrLDPC_procBuf
     // CN group with 8 BNs
 
     bitOffsetInGroup = lut_numCnInCnGroups_BG1_R13[5]*NR_LDPC_ZMAX;
+   #pragma omp simd
     for (j=0; j<7; j++)
     {
         p_cnProcBuf = &cnProcBuf[lut_startAddrCnGroups[5] + j*bitOffsetInGroup];
@@ -1119,10 +1121,11 @@ static inline void nrLDPC_bn2cnProcBuf_BG1(t_nrLDPC_lut* p_lut, t_nrLDPC_procBuf
     // CN group with 9 BNs
 
     bitOffsetInGroup = lut_numCnInCnGroups_BG1_R13[6]*NR_LDPC_ZMAX;
-  
+   // #pragma omp simd
     for (j=0; j<8; j++)
     {
         p_cnProcBuf = &cnProcBuf[lut_startAddrCnGroups[6] + j*bitOffsetInGroup];
+        #pragma omp simd
         for (i=0; i<lut_numCnInCnGroups[6]; i++)
         {
             idxBn = lut_startAddrBnProcBuf_CNG9[j][i] + lut_bnPosBnProcBuf_CNG9[j][i]*Z;
@@ -1135,10 +1138,11 @@ static inline void nrLDPC_bn2cnProcBuf_BG1(t_nrLDPC_lut* p_lut, t_nrLDPC_procBuf
     // CN group with 10 BNs
 
     bitOffsetInGroup = lut_numCnInCnGroups_BG1_R13[7]*NR_LDPC_ZMAX;
-  
+    //#pragma omp simd
     for (j=0; j<9; j++)
     {
         p_cnProcBuf = &cnProcBuf[lut_startAddrCnGroups[7] + j*bitOffsetInGroup];
+        #pragma omp simd
         for (i=0; i<lut_numCnInCnGroups[7]; i++)
         {
             idxBn = lut_startAddrBnProcBuf_CNG10[j][i] + lut_bnPosBnProcBuf_CNG10[j][i]*Z;
@@ -1151,10 +1155,11 @@ static inline void nrLDPC_bn2cnProcBuf_BG1(t_nrLDPC_lut* p_lut, t_nrLDPC_procBuf
     // CN group with 19 BNs
 
     bitOffsetInGroup = lut_numCnInCnGroups_BG1_R13[8]*NR_LDPC_ZMAX;
+   //#pragma omp simd
     for (j=0; j<19; j++)
     {
         p_cnProcBuf = &cnProcBuf[lut_startAddrCnGroups[8] + j*bitOffsetInGroup];
-      
+        #pragma omp simd
         for (i=0; i<lut_numCnInCnGroups[8]; i++)
         {
             idxBn = lut_startAddrBnProcBuf_CNG19[j][i] + lut_bnPosBnProcBuf_CNG19[j][i]*Z;
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_avx2/cnProc_gen_avx2 b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_avx2/cnProc_gen_avx2
deleted file mode 100755
index adeca21040b8a4c2f1e2ed8df791e1ad121d61f1..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 201040
zcmeFa37B0)wXnTUcRCYEx--v7hs+@}NeE*CB+x*Z!aODnNeG4zNW$QNfe<93h!+*a
z2|)$9DmVawiUBm>j5wj9q9O+5dQrJvKCfQB_pNnypVOzO)9Ca6|MUD*_t{mus#evi
zwN|ZNwW@aQw=P|FNKK)T<*p_>AoFf<_r)nHu32_N&)RhFWpTDJ>&10^wtLo{`??fo
zifM~m_^%X;&i$S#HOnlm8^47$5wWmlaSG)AsEE#TKgUqt`butbF&O^0*F?_T&$7mp
zZmhUAtdI1D^=GB{+&{gD$IV4Qhx1mrDMh#`MY!C5B8tm$KX0FH^LKo)yyI&YbLahH
zy=+OkmVEQ-j``iDa}(U^DERo*2d4PkZx8NR;KZ|9*HFy3yjWj*ba|=RzT7X~X0z6<
zJ$u2tS?kW7v2N}9&6mx%Y~g|#3+Bz-c;U>ssoj=u-b0T%A=Q-Av5`C5H;A7yVET+F
zU#YwO;irG`tuO6+=WRo-dGf?R?sKcK`Hx`LZVWjGw2^ywJMk0RiQluG_<h=mpW9CS
zGU6NgRl0#hw1wwx?ZofVPJ9L*&XMd3vW*)qUb}wN>TLCe8&<8)Hf-LsF+1z*3oqW3
ztv+Yng&S98t1rEH?IyfpwiPP`U9oY~Sr>0walu(@*JmqMthwOA^~IPK*`do0JLupQ
zb7#(-IbZB+%Kq{@dE_7c$}G6eBi8mZ^|ZLnUb*nB6jC;O6yx-UZHRc|gwI`LS$uO>
zBymbvd`S~!+3d1-<tldz%i_!R#p1H~^8V6P7GI9%F=g?2-?omE%i?Kpvs+mf-@7?B
z%bK>n*t6-nx^3r=%bK?B*i^S`D~U~8zt;27vP=YDoqsV|UY)p!YyH^8guFk`OwT{_
zDsJNW-b=FQpGfy-doQV;-;wT5^<EM^e^0t!?!BaW{?>GVxc8Fe`5V&xLEcM>=eMN$
zeY}?h&u>WgbG^6e&#z4P)4aFI&mY76oc}m%`}fam+WwoSt<S!6%<+dkwqwiwi?gQ3
z9&Sk9V^{CHINNn88DCyqKXyr$eeqHVbVAdN4R}pkU+LGh{dbqvobl)vDK8P`<ukr&
z(yPzZkKJP27ro2#Km1B9`J1*s()92Pi<$~gG=2Y-%>X}W#-?pgZhHBQrtLce{x?PV
zE&IQJ?Ks4;{|P|ux&lPb*jaZCQH8%eDt()_?muh|88(e+Mq$tiUu{IolmFEx&UpS!
zfYgu8p5KUX8BJHdsIK4s%JzE~{_m@=uHL?FKfI>LmhM=5unk}O_`%^naR~m_ub3&j
ztXBkTt{8RQHe*2ZFp^W9yPAmDHIPfBHQn5F-LkLmsK5WcspNMq-SW`M7P<Yg$i9}G
zO~$?}ViSDR_NBX;w!URowz>YR?<RiN5B@=+4{>R_j+E^WKd8oisKDi`x0=4Er4*Bf
zHYeR{(y;bWA^Ss5kfRxu&shFrOP`s2Kyy<!_a@?%Cy4mNQPJo^ME%&PeT#I6sHcsZ
z(oB&tOLB@VXvX`oT_bGBfBn6L?Z{?q7XYy9eA0JrQ&yXHZo3HYhMn6k#>;kYlV{v*
zio4BtO?i{&H5YQSg-mR&@ZkqbNjI3(yDVuzGt}cI{bykHO8tG=)jR61{w%$a^1ZFU
z?}_^RlVsH2{m9lGV;_E{Zu`=wzt|mklD0ol*im@m;b(fJ=%*fA`ZDp^^J{>=?u4gB
z@u6&K8JQ1_dY-v1dw5sf_D8N;`f~k!S1+~6_4n;4JdyyWlmiSYBbUlM_`Z@XyY?+h
zn%SImvq_C@RwGH<spjtgDRG6qU99GD%lctiQi-4qhmiC@n@LS3eK?ZJ8+!NBr;07y
zLXKw1o7XyL8A+aa=P`xWRLROJuAs`qvZM;C^lr1JoGNYC^uE8fOPDW}B~=jS);5z8
zVYWq5C1ILtZ$X=3W##m1X3KXa@ctxiUHWoi>swx~slVo3Wujf`RlhLfATq9gY?~_n
zrHsIG0?!l(98chh8UiO0$V@spPdYVEIz3N1lRyIZ(UG9e&Xdl~lU5UWMsB^*v~@?J
z*p+^PqAH7Or#lUzaqV}fcTq-jcRI98c3ycUapxK8>lR(=;p<L#xoP_oO@$pkRlM$M
znsJY%-_QS!cMfVpnm!k$B;8seO+P71s*t8Hll0iqG@AayTWMh#5<9Ou@}-t|JYIkQ
z)k|eT!l8R>iJn<j(UN9Prw({rSyF|ZEhK3xIBb2(O9+7vXG``OQOcO4u0F~r!!hZe
zcDm$8|GQLBh1l&RsVH`}_1CN^d-RmVZW1io^&v7MQjOrWPTAU>z*7b$5Llx8O(JlQ
zfhh!%{7uXAOwaSo%=667^UNiX3Y?ecS&-*hnCICi&$AzaROtbEp2c~dgYrB}@;rwS
zSdxoxO;LOwEs3vD?TD{~sP@Hob9>^u_g|aEw`bWC;r^??F4+*3ww?&x0;nx%om!Su
zA+7yL%BA&<MQJV8`S5j1le9kkn;QCzf?BM-&Caszze=)EA*gqiC6(kaJt^KrQc+NA
zFWJ(Lke(m#3TZhx+7Z&fzg$A3Z*z}1NZA{gYD>DYTm3axwkf2?nDG_LKmea1#{^~b
zH)b{PEP*6t&k?x6m|X<EVBiG;Nm^edkTU;~K+60Qft2~r1XAXg38c(_C6KCkg+R*u
zHv%d1-wCA5|4Sfc&ftE^TtgsL(TzaL+?_zm+>=1c+?znk+=oEQ+>b!2qJcolJb*yT
zJcvNbJcK~XJd8lfJc7UtxvH)$ivMp);%`(t;_n=#eer)!d*Z*(U%(+0XP=hZ`{8F4
z#aw+iQa}gl`!9b^#kAEShD8l2siH&t1E^w$czz4`w?w2&gXg#;6|SVTr^4S*hDSxu
zxS=emqGxO-sn|1+)k|bc+bVonlwt2EQmZ2s{>wj=3aU`ywW-F`JL>AMIhz*cHI`KP
zI(x^@C}ZcgTgfnN=eCdH&EC1~HnZ>Cc01n6o!dT!ciGNuAID>K{t3K0cW%1_k0JY=
zcmRA74}iPy0Qh%206v8Wz^Cy5_zWHZcjHmfJ$L|o77u{W;Q{b@JOI9c2f)2}0NjTM
z!2Nhs^hG=X9>4?OK|BDyga^Qv@c{S=9sm#F0q|8kD%ybuz{7X|Jc0+nqj&&(4G(~?
z;{mV}4}iz;sOWJ#0KS0-z&G&#_!b@j-^K&rJ9q$m7Y~5%;Ze~OcmRAK4}d4}0QdnO
z06)Y7;751>{1^{_pWxj9iyT#TEB4FZminbp?et4+3GMgG_qNwBZ~ITMh<@2n*)MCG
zrqVANQ?0a9T65cDsxzaEwmRk3vZRVmc^*l5r@Xq<DT`RN=#)7kg~was(#F{8$v>v{
zBwQ*w=6{zZRdmd!Nh)^C?)BGP+<wRWe3W6wEF#)b$6Q)gqo%f)&|PbPJ3rN!I%bdh
zYtB*@imG5#bH?|Z@jx=}+_snuh|Ym{h|WP~-?{BzJVa*+9-^}p4;eiK50N_*Z^zDU
z8Y!OIx$Q7K1n_V?z>mNKd>J0#N8$l~6dvG5;{kpQ9^l8~0lpj$@Z<1??c8=e9^fb7
z0e&JL;3we$eli~5r{Dp8Djwjc;Q@X+9^hx-fy9}3fUm#<d?g;>(gASw6yWFJ0e&tX
z;H&TeUyTQN8jbGUb{=<tYg_^Rd_2J4fCu<GJisr&1AILm;1}Wnz5$OmT!gn0!vh}R
z8}R_&ga`O$Jisr(1N>4vz%RoC{Bk_N--rkJoA55%x$Vt(fWHL~@GI~De=8o~TkrtC
z5)bgJ@BrV62l&-^fN#SCiEHoxe;Xd)*Wv-b9S`ug;{kph9^mi51N@zMfM1UX_`C2x
z;s!jx-;D?Ozu^IXBOc)I!2|rgc!0kT5Ad7t0KXXz@b}~GD5{~l)@sP8f2|rC`3G<c
zH8iNT8gh7m8rspZ8v4l#sf@PN(BI3FD%8-gNoqq46|tyLLxG5Ds2rCz)X))S6;`OB
z4P{9cYUl)#ifX85hiYhgl%X0bBHED}dg%EQVJgN4za^<S#p~5l4f#9?eRZE|=)vYP
z9@}*Q;cq-zG^;k&g;{l%ribm@Uc}R^njOj19kXg}_)m1l-})6ZC9|r5WL7nRS+y6*
zVJH35E)0iX=5pOO(@JL5RI&!tVHTO2RR@Tdu}4SjF5%0~s>c$)>&+Ir#+0Ix9n{>q
zm8L&kmQ*sUZZ_#*lG;Rtk{-GtDh<p}vJlLwJD^vwsbMhf-xOw5+fy{FjxY+dYNA8r
z8gCS4)gncHNzqa6uYRB7{n)NY3Ge!FbHu|BmWFYE72AQ}5N6drVOFKv`#3`hXjbKJ
zQ`~LF>yuNXB!<I|qLA;Fm0wCa#-z`eC6&yo*P3*5B(-Z+m47YFs`Ta#Ml9uK)g6@I
z%<-3=OXMgws+HLg!>qci9N?<~P@xwZj|S&w%aTfZ;bfD((PlNd0kMs0PA)5})a9?W
zthbaUl?eKTNoTj2)bkjU4sDG=X?nbv9L*&8#qT;INwc}J1yw#7Fl|xgyJblgRQY_H
zHRV)kyQW2D#Z?gI+_Iz!!W`CSQX<UE)<{U0=Gt4(=HX}a-t+K-CFOU$1b&XB&djPG
zGUHds$QXq#vmav=JRX>uM8Cio1&_{kZbYt%$kh?K1`mMqB64j+o*$8Kz`LyYgw4&T
zzoti&Ma2`gRkuOkcF=8Zq>S8rx}#i19{6p@h!cyJPuQaQln3mssp#@?ehZPgB#LND
zWIj-qR3S23NXj3uTd9B+`rIlaQTBjs#>3}pIV$mdZGp-kepBLVg-kV+p;94J{{>X>
z`HBfuh1gmHCJFm?6kmpC#q+g=h@Dx6OofPTO*N)rJ|<KLw0Vss#r>Qjb}AV$IBEJ!
zM$EYclEHKyforwgFCeh8mOu;BXUe1LGvzrT&$F07G6Ee$AQiYI&vQtgrzy{Kc%Ek&
zfmGm8c^=K!shs6`p5ya8Cla`}rYNr+nowJb@PH&|Pqee3R&GLVA;N!srdfo`ZHAao
zC0oga+Cowu4xqM#_PMg83ZeZLNkyUkL#HOxV(qyJwMF#@mDN!psB6lSDg<>INku_z
z(}bFYbaKEeq~+vj=Na+9uS&Al7y8H8uI5-|@0TPM^<cXu)CM!&OGX6nCB%58=FvYp
zO)&5>fkw^ye<iTRz$*mO%9EzgBte=!Q)W${DRcH}F>?)pl(`#$l({>Bm6qI-K+4>k
zz!po^^qDgEBakvT5J;H^5ZEEqAOb0~rq7gF(`U*&f<VeVia^RdhCrhwHxfvhcPEfC
zPau#oPa=>qPa%*pPb07;UqR^5gxX5{-Ime5sixe7+Cu#Q`xnjP-=PV$!D&*96|fc(
zc~2D6R)_deSyDxZc#x!Ai*Et{q82YAQl`aQm{66JG81YGJf@UYR?#z#EK92B8FNW0
z_KbE-sHu1KiZbjSZJSVAsPGRwUFsbbDtre?#op1b33a-?<0dj9MNYl<QwW`PUuM7w
zcQVa8*M7+ur`gjLxmyUFXW)YblE{6SK!UoJK!UoBK!W-hfdusl0txC)0txCa0;$qZ
z5lB#<A&{W%A&{UxM<79cfk1+~k3fR@B7s!tg9H-PmkA`OhX^F79Rw28BLouE*9au2
zodi;)j}u5x-z1QrzD*!OeV0IjdV)ZLdXhkb`XPZ->5mB{sHX@dsGku?P)`#`P`@OQ
zpq?R+pngMOdfpRrqv^Ayu~f-u+NvjZJeGQ2dt<2!e%9O*D~zTwhDm*Z@zjQnd*Y-h
zrmdcML|IZrPn=Cs-V?7X^~Bb8)8crFW%0C}p<K4t7eDyZlK5Bj#fQt1D*EClNGkS4
zdd4OcVm`PjWlVkXEm4Mjv2Ckqi@sQ2R%1n9oR?}$!zt{vD``<)V`(_mWMABkjA6xO
z%BvL<yVr8FhZPgM*YVtK2rDLbuM@e$?xhuz(frAH0BFSo;8Z*Sv|<8qIvxO8F#$Le
z4*;#0RFn`3D<%ME6A6HWJ^-|00-zNW0Iiq+XvLfzR!ji2VgjHQ69BE40BFSoKr1Ey
zS}_68iV0>L@Bq+?3Bbj80BFSoU=tnyS}_5*1P=hMm{fEb9spV~0eB-G09r8tcrzXV
zS}_5*0uKPKm>a^134m5i0ItFVKr1EyS}_68iV1*LOaQcE=F1r!+7Vmz%<7jjT0A3v
z@MExO*N#|R&bY^J*<v}P#e?ZxQAS(c@(X2272WdvB<0=m>Qc9C+m0BBIL|4^rHy$`
zZCQmC9dk-qQmMZsqe5SjiXF4v<&4xZpZ!rKxjLHXToSnxVM@yx=i1*sKvMA`S+Sf^
z>X@6&crh7wZp)AhM5lm<=+xjLI<<I+PB*;Ec5bV~yJ6?H?s$k?54;^axAnwB@_OL`
z*BcMG-SB|xg9lt+JmC7_0auR)Tmv3({qd-F03L7y@qinI2i#yh;D+D<Hxv)JVR*m|
z#{+Hz9@UP-18x)^aHH{n8-oYjSUlhw@qinL2i)#>z>UYF+6j2TO~eCk5*~1q@qn9x
z2i#OV;HKdLw+9|@)A3gB+%^LbxS4ps&B6n2HXd+u@PM0(2i%@`z|F%0ZayB>F2DnB
zFFfED;sLie9&r2M0k<z6aQoo_w?7_m2jEfdB0S(0;{kUd9&iWY0e3JSa7*xjTZ#wV
zA$Y(Yigza+({;`6#RY|Ll^)SXwPWt+SP{IXy+`ynp9Gmu1jEAIktF-RtG}-7m3Bt9
z==tvrptgGcgJnq-J^v#l<#WX=TGm<GZd2P-c)@KBGuUO{k@6W(R!>ET->WRCqQj3O
zso3G^ewVfXB>v0y+ayanbH;6vJJF-!NqiSc#SYI>g-;S%o-&R?`Nib&-FEmZ$+&ad
zt^dH>%*Fyd1m-rp32ZFDLvB8Xhnei-c!<v@@Q&ZP?G8Mo=uW(KY%IV--tNK!{NM2a
z{}dkJpT+|`ZE9v?0e67kg9rF$@c{oE9^jwH1Box-0e&wY;P>GHem@?ye-RJx2k-!Y
z5D)M#;Q{_-Jixz#2NG`52K=jdfbYNq{9!!6AHf6sQ9QuEh6ni9@c`e62l!)nAn`aJ
z;NQRl{F``ye+v)rZ{q>}9X!CliwF4k@Bn`T5Ag5ffy9$|fV+7d@E_s<{v$lVe~btC
zPw)VL3J>s~;sO3MJivdB2NF-?0sad-z<-Gc_^<E)e+CcmU*iG(8$7^&iwF3#c!2*7
z4<w$$1N`@RfbYTs{CPaUU%&(W4|ssThzIz8-~s+eJiz}G4<uf~1N={Tfd3f}@W0>z
z{xTlm|AhzmU-1C{Z#=+X!2|sN;H@mGn;u1VQ?`x5sCLv1`oyGmOjG6CC|Zm=PWvv^
zhq@Wn(z^QaGj#ppHj0kB{?I6+E$y>kSyF}e8AnnZ<BlR0EhgqUB91#&mf_OIxZ}F-
zr1m6SD%8+DWl0rk=)EKr)lj?ZmucLwF3NC1P(-w&amW9DyM#=I8XBK!OcR2N^~;hP
z`iyGmZ<g`S_rCPES6}_&GekUaf@8GpKjGDrzchWkY5Pk}+y8c5&+WaNwm#AgthyD2
zr)N=ko+~}8jA}=Cx^*Z#H@Ek!8WZi48jWoVPd=Y)V7}UcW#`A=D$%L5w>d3z{ZCm^
zg#bN6QZ7Jc_W2?vZ3s|4p_G>GO(>5jtFJ<SHk2h*$j=ER73HUYhxYmDQAQcXI+CA<
zzFDG6h5Y=Mq~c?2K>an&=JLlF{iFC8`<C+aU~?I)e-kdQe{X$p!|KPD-cW;4XX(Gy
zdVNnfukWk#dUJQLxAgG(!Jb|}+{^2&y}jPHo7a!^@%o9rUhnMZ^{#rapK9>>nE_t!
z8RYeIL%e=rnAiJ8c>UriuMdv#`sGHi54quU>5eI0ADQm;YqP!XoagoNg<ij@L1pQ;
z7kmA#`$CsKag5g|Pxku5m0o{*p4X=~c>S4nm!(f{@%qafygqZQ*WcXZ_1PU>pL@dV
zu4lZy@RHXTGt62`|ER5W=}U{f{&}U>m$wuiTl#m1oBd(IbxZ%=baVavOP1b%96e;*
z_Q!U8>{l$fx0Nt2@#^nvfdBj4E54T2#=r4syq|X9Ne6C!^}rJk+y2)BPdIG*j}AP3
z**hohnmvwJ(B3&i|F~sSe>dmnO%MO0);IcgO?(_aZ~Ko;W9r9VZLQg|?Jq3b{?{dx
z@#>(bo3=h$XxjS^n_uunzthe*@bm-EIPlB^S3G*d>X~`|zdVZa@ZG@HuL7p>I=d7c
z1^$z63)*JO?)*N<?@tsq3H@>azf<_7R}CvFa3*#md4C-FxAZDxwcYBv_vqQH_rOBk
zfSz?VHHB`#X0>_10@P{Qm{C1;>(#AipPoJX^zO4;?;gE-_wCVhw?1{<eKiW#XSZ&3
zbre=t+a1TXt~(`nudOXMv#wihTdt<2MhtrP?mnm&m1aGAc!fAMHA9B>uB+?Uqi^?~
zy&8J;>DN%xty}l*Jt@3zU61Z{HMO<f(jPcm|1@4lE!1?YEf8x9%3ONUwO668wufeS
zvX!MZ2Me`>+fFFvn1s*!_JtZsBV&|N1~CAf3w06EoZehI6s@hR1-5H$5!si*t7ZJo
z<aaH<PZ8&flYb>VxsYwSkV3ce`*c?e?;MpatP*W;nm?J}-h?mUcQ4_c0lS4NxAZ2w
zmfwXDS9V>rWpQ>8_#d(5=<L|+q%EgyIV(G7%eiGaIt)^K{gxrw$So7M%*pnorb5<z
z%fy6B4hK$I6Tf3gJ&oTQepm5(H^1A7zn|Z?`8~_8?lsWI{^E=22p2dc9;CKzCM+*L
zL|U2KVt;gHZ2~{{#=yG{+}_!KTlUYO(w2j>rCScknzkGUt>AS#Zse9xTgGPNwoJ*U
zZP_E6v4y8NHTHr-gR^0kFbHXft}=h+{aZV69Tr|iVr6|@z3&9QPLt=%&*toz&D}FQ
zY~8w5YtCBNxV&-VxybU&nVgNV;hYs~R;^#LdhNPZ8)uz$$z^kAt-pBLl4A~DanAZ<
zF23-b6$c$Ucg3j_&s{Nb<B9`MJbCWSbFxdbgU?#O{=!X-=Ulw%tWB#Lv+--!pR;cB
zxvLuY+qmgmUhkiI-T}SKBG+DU0g=4-pW<o!B^Rzex3R-orU0;T#inVEfy6<ZS5I#h
zvwYRYsf};you%^w)~;VOy>V@e=FOTV{;M`_Y+Q5kg_}1tUb=SEd5wEE9(2@3yRojZ
z!mU_w!QA-^);3;#!3DFYH-hx^#*J&%Prq>es*TexIP0=y%a-q(Kr6r+%|P7#jVms&
zfE628ZJM)U)rPeTr%XBLyt6KzI%jIza8YIlaC7%ckmdEQzVPBksnfW2|JnPl-EZQ#
z`>x$%|G9|}S$RIgwu92AOer>O+SF!pPCaenxqGZVqiwusba`vmu2~<gNrXtHMuRHr
zgJNZHXPvz<z(k`}JA`eSpF8qzUN|KYzDUZJg|tJ*_VAT?W$0#Y;oHo#memJq+NrNC
zf+~$c(=vWGQ!X_LbS$tOi?{U7+7#1y<zm_bqAmXKk=Wm6LGz=avO3$VazW&5vy_Fc
zN}<5^3Ys%Ja+6->((__>wD{}ex7WvSuaDneAHS99hR%jiWm(${b~XU&to+W>+pM$;
zk)7e!S$YiK7ViBT$8U4~9~r;3sO9zXTN?MhK7M<B{Dz(=8+|qYzcPN?>t8jt+q;8;
z@^N3ABgi>L$d-e`q7I#%t;}x7c4RMQjfG<hTMG9So+&icEUwv5b8F2LHCgTK+Lg6g
zRe5GtQI55BR##xuF+Mrg9pRkkc`0kZU8OvY?Y6x<&oS-Lr)8ckZPKtZ&pmC>xpkgr
z3YENQD^EiOzuL~TxCKw!%d?@3@9pQgwOKYg%JW1`$WO<4vLs`j<(Z8fzBc#z{09s6
z>-Ou{?bol{uV1%ccQ)avNRQPFm&#aMO6nKIpTfrUO5xq`UA{9W)*JKub;Q(U8l(E8
z)Ipi6;={5bTqA#7Iz72(O6{9YZjSt8vVr88mX<h%WwTTMv0VG6{DbhbY+M`pk0E|o
zb}rY&>5SRYDgX3rA~A<$Gq~=P@L8Qwr)81f#hb<154eubT!EXOxoIQv-<9(JHTwfG
z)6!wIqqEh7-;udQ^?ddnt{+M<%L>M{bU~Bmg*@76jK$=kmia61JXN<uQ$rCWU8{4o
zse}Ub4p*B(mKvCJTuL3eyA|u~p155DMeF#h4n8lvdmbqIEWuX9w0*0r^`QPbuF6Vx
z>g@(>Eup+cZ9_(E4|4Sewhvb^@6E3lCG|<+jv({2ew5IMzaGFTp}qL?6z1I$HS%2T
z`EsnpYeVuQ;;I?Y*zy8Dq3ki<8zcX#fzP0o?JlHNdp3Gc%8{DVvUAsmcJ4+AV%(P+
zr9$^akLa_Vm7r!&PgK@bllAWmG^N*4`v7Wh;MxF8fAHvrZm1<xUquOn$SwbeH}iiW
z+9&w$`3s%7dNhLk9|_bjC@_d?*Z3d3MNKIGq`cIWhdny0ob+7s<$rHrg8xER$N%2Y
zO<9-!(ku915A~|$|M0~B21*zSRPcWUWey>xa~J#{3DsJ<8omxtjg$XVfSy$3|Kw~a
zbevi>|7WtW9{isG#Tp6E0Q0elCM>mg>Skp7Qr|STCCmehJ+iqhxc8#|G2k_>Q|OR<
zwT5)>17zRC|K8m9>H`0jb@|_y=ci@)Y^<qD{^fsTHiD)5(JB9MzL+o!+E1*K|5NBW
z_WuUpM?$;t;N6|_ra;BfRkYtHZU*GA^dv6<RL}pt691R;-HH9O{j=k;gW<;s*(_vn
z-%@eyhR)8GL$`giBdNb8JHCwn`()Mge>MEy0Q4I8e{qrjhh}HATWcv{IMf;q^#{ZM
zQ9zDHerpmxs^$M^q_scWQEK>_#>8g+52K7~^xs^@JB@6Q$@za^wuF(6{GZ8R=WZpN
zUJj=2CNMt^{+~u04xsLp*-=&UzX{lu{C6u&wfsLVdsnsv+Aq)E*UbOZ;s4vZ#Q)nF
ztG$CdbN;`LzIa>q{?419eLVI5UuK`pcCp20O?Fq}|3~TnUFH9jGXC!aKYF#;V$>cg
zHAwE!MgA{O{GXrtfA#!-d*c5pxK+<+SN`9SZKR|t`0Ly~k@$Zx2L!z{do=O?^6WF&
z+q=a7r{Mpc^uHVU)8+h+yN+=<En8HWU1%&U&kiZPnEglU|9uL<e@En<x#8I%wA}u8
zUUqu1{~eUQu}k#7JG%&Zt3d|sfA7s!LBGqY?0-*Y(+Z8*Z-B|^|7<q9urd33mGmFZ
zCb$n#=X=5b>1;dUo3cm1|Gk9o=&bRiKa%w=1pbe-z<*)kXI1GBt0;~1BNXG=(lt$r
zin-d(Q7B>>siiVYWptEMDnBo$SX|X!K35Xn(U<rB^7&N6#8^GjB5VZ#>-aZD?Kz|v
zM;U>8-hz^!Lk9kq)ph(G^+zp%L12{61-dZ~D$Rmwx$`gbn-Vj(D4~|xoiXG%Tat5n
zQyrPceB3q(XFf-mQF=aWNg!RiSe9ivcXSRQcFty;SJtH(qBzIH&giVqe5MA3DYi2(
zG9?c=5(=wC)FGA;vUKqm&RL_iTB`ZG?i_8GL&nS}c-ht%K4{jn&GB8xggGLY*w{9m
zEp~?06I|tXxV#2)<vEK<Rd~)fx+MxYZi_jD6s=_>B>m-$bgm(vvlH9t%tR?>(`Tw7
zcorNo#S(jx<{aMkNM%Pe;;ya7_@KD;$r1CLx4Johs<e2KdqM|aZHXo7Td(*Vb~LSp
z$<*G2o%0#nha8Un&22kl1|=@L5m!UHn3~VgxpO3?Mp@BfU|ai;E*-i9VGFzJq;em|
z?b5dnzb~a(_imKkn_7DiGR+usbxR{W?G3ib*}IgrWzNLy6@Bq-M-Tpbr`YICJyO{P
zAe<*CEAlhrP8^)K3Hw@{QYrnSOzEg}ggyy<6SAqqhW0Zy@<c9Ea(IF`<GtqjLc^FV
zLP8tz&wP1a0<XbE?+tCH)QgL8p@Woq`=0djr|g;%^_$n+rYL!)Mmv>1p_ENyLQ91X
zi?V}m)@#VPt~&V^^(h5`i=6M3?xJT{rmd-k_x{Y)JxPwTV_s#?UT*&jJDM2VYI~Ng
z)hcF>QSy~{sieG12ivBkM(x~o!6~!$tFXK&vG%%<TV-5*Ax`!{CA%A8=g8J8#$qdu
z(oag*U-FQ>#8&6}NXfTfSwq;Y>?yX%S}oQ5U3ZoGUmKMDO6}OdFSKN-+~{RJQ<|~m
z>0%#pP?Cj^4f&z8hyJ%6;X?n1r9IDCOsc}uZl<-TA6WE<27{qN13z_P1NZ7C>D-rm
z1!5W!1+^LV0d5dAXy<hPANt>1JxB@tKM=UxxXbnb07_Ml4WvFTe0{msdKUV>FHl`|
z11PH-SgRL9PILXQCe8K#0IU(Y{vS%X8?)?zv`GCw6nsPfH-L?$^rSp>a6RdRQ_J*)
zA3|z9f8A+$AAbF?erRbNLd-DkyH5Y%&}}4isG$s3Eu_tEsr~|Gi|cNb-y_ACYasIk
z>vqQMYau25Ka!jSNgKt?V|c=K2!0>#22jU9${5Afo;sXb>JvZhyXyZz)H94+zN*?)
zXOFbq($L;$A5<3_R=X%YrpHq#*Z-y}DaJ;M+%q=DK9&(BhwhEuZY`Foy)yK#HCVQF
zTTWM<SS!Q&YBQg+N<ip3wTxo{aR@D0;I0>OKBd)Lp?%G5O6Y%~#b2$W9*z-)x=lP|
z?BS>-*2T;dx<X!b)%6Ejed*{!%;lyuQHpAi&z}4&x1OK<E7$+_`+@w0#nv9%7fH8&
z_NOgUL4Bi?ME`6cuYKH>sVlTM+JFC9{Xd)%3dnh`|A$fT2xM^t81x}N*Z(8HU0pJO
zo}iXernONI1~2=wl<ftEgOP6Wt0AQ9XXH{l3?WYaKRjWs{%;_UR{w#i?izZN5U<4z
z2dI3lpg(1n^#1^AE;$dJbe%E-H=hkU`*H3<|Ht}g9yhocr~|`Va2^51qp4#6e;M~W
z^}n>~sw>z3lcDS$&>-}GBfekg9ZwD2x#s$R9Q>L>uHB)e`hOfX4<m0~;^GvpO4ArH
z8U~KzNuNjwS~iCRr=*T2egf3DzR>@2w<qyk*Z<S8Ifee8LW%a@T>nqzu3Z050`ErZ
zor5fl;W~p=+&*Z$(ElR{HIQm4x&EI@`e1DPb*wJT;y03Y=26)8r&7xx?gx>3PujHy
z@r|^0W|G3LaUk^n9>CATb}an|QvRM$sgUiJ%?H=rs5|t(xzzu2!E0~U8Aj5M(Enq>
zXm4`P0jGVCkG+twdB6?_`w?I_o|GP>sQ)Js%WHeYj-_RM8I`|5Y4zf@>3`=z_C80C
zY7w81q5mCGsg?SXp3kGyhw583y&BcgKrKIYSg!w_YdI?IMoFgC6?3W09Ete+b)`g^
zuP3KvtN$&lt1k4v`p5B1=zr@OfZkB|^(X8TSUo!sO!^`(q5p@{l3vJ%qsi{1n-cne
z5RfhPzkO9bC7zBlx^v%<N^(Xsn3T{FuT}rM+T`<p2xa#sr2Zev-R{Wi?r>NAKL!ky
z_EE$SqV`GT8A#vkfkcfYUHw0aoc7icKo6p|>i=O#T{qI~vuc8ol&Gyz{XdQrWysZw
z9;w`}(tkds7m)Yese5<I$o2mMTBH7-1il&ayMP*|5;p)zp2|=CKLd!t^p2ALpH9kr
zWM2J02l&wcbHGvxPoQ<>`hN^}QX$6wdnJgj;_pkg`vX+I)-<2~#~Yl9r}MycMsuMP
zxXV~C(H#Iy!&U1431B+`oF^31bFDs=)=s9j188AM|66-T9h0GvFCur%h5p|^Ju{C(
z22SGJ?E68vS=lmt_5ablKHQz_0r1K3f9U^(q=f!I5~*H7UiJT6bjiVRu|7K-K9uYK
z`CzR6m#;@BS(=HhzAyKVFAjmbJ&FHk^#AGbyj=gE#$D+DeW3c`a9aI;GF;B}|H^DJ
z(scy9bH!5qe=-<`{$E7g8KfVUok`0kW#{l4$-bdc#GXOgpzKtBrz5$?qD{|b<!D%T
zcIw|<qyKPLTt-qtBWqZ5scj8Zn957+>i>;N{~y{y{~rw<*F&+*Q0^pfSORx?u<F*G
z81?@#*(J24Qva_Y<zV#x(MZqPtd6bW_3?E;9SGmf<?o--|LPR=nlp&8U{}Mnr2mJ4
zRX_OMlb@C@XPFJOIP|}%>i^Nu)mg|;B-|YoCH?R7&e@o`#*pHwvQN7hPpIY88P*?V
zb&dMIRzHltq4>G}9}lM+k(jCc)c=jtJ~in&TQHHlq5o$g&*SKKBj~4N$k7)*jRK;U
z77PHd*ijPW|2>FN|2u1&LeCjP4{jj8V<gw!L;nvWrK>K+|GEA@02xyM&!V<NDfMvV
z<8bhqi$sh;nwEh565<EZ%a0<@KvoZDAwdU|J|B#ZBB%QQAn><G?*-nAp}=&~2BHy$
zqty<k#L=YGpl!yHqIMh1XhJ>gc(7}3K7Fo`y@8gi{}&;@uA?1;jEDX|lb)3!sSCg(
z*Z*fB&4(k&Gm!ryk>$|;3z6n?k?Z+L_<_j!99pXWKa9|R<O%(MY<hAnq4WkQqW(Vu
zX>z9a+Vp=@QU7l(Yqt8osU7`)D)~bHUjqi=&cSOch8_Q}1KSBudtEUu*Z&tm=gHZ&
zHue8zQm%Ln`u{vQyoS}n)!A9uzq1N?chdjovYz=dsP-m!ax`m->i_q_r}M!1^6Zps
z3oEsu|4)Vkx&FTp=~4f$pv2o)58i;x<m3PO=%<T-TYx6L1Ab3{KF3kt0(7YQe<go+
z@aw88jsH8-|JQ^6wMqY90q5V3^gNDCssC@MeOF~y)3zPpe?EA>1xf7A8tk2{>+j4i
z$gT(L>$9!M*C=8`|38AXpPqdndm!omFVnWyrvD$HzurzC+r{1i_5WkpN3-7}pO+W)
z|5xc*Z-ts$(^KLxc(oo}|ASTb?;-zR&b~tG58%D}|C6*y{eL&Bz@Gx+cc=0Ho!L+5
z17FHMN7?s+<#(t>{r>~{$rqCTe@7bsza@K5SIJNQ*7|=Ddcgxy9Fvsv|DME6rx(sa
zSL{nl9sSu<_Y93j)~12OP<pSrX*ybcDl$@^=2z-}bE&Hr(C_6<FZ{icud$T0khIYM
zrIA*(4YAB7bmbT@Sd_*Ox&A)|EjSOoe+;#sf`2TvmGu8SxH6o$Gm`#43T*dB?w0|v
zCwk`~`paQStEm6?fpY`s7rFjlj-EXg*;|qH|KZL0zX{FPRo5Tf`Xp^R5-nNM|K}h9
ztFv3cCG`K>$g>Up4&|qwzBc<X?J3v)+vt5CrU!3EHV$G0@{Th7|7QBeIoStE$@Rbc
z9YX)V1(ZYouSS-->T>=6Z|IlZk=q^YpIOfJm*^hH|KCme|6AE7vU}*WyU|bQWZ&oa
zVD@SBlKTHAw8y9Jok;T!v!5bCPtt4mp%<0w|7)Q2d)OCoEWPDoQr<*=9m5`p_t7uZ
z{}-cuK1z*Ubxri3?*KHgAmj}R{Ok0yr?Q9A{vpTzUrDiEz5vEIq<!R!mkPQ5{|hO(
z{{H~szth@s{r_=6afQOiIZ9}7!SVm6;oWVNou%3{xORWmuh8}J|FFV<Y-nL=VRhEO
zp#EP`aQq+o|3#?uWKsXW%Kn<r|5FRS*m1MC@FczSYgx~N`v2wZMKsHW>|>dd{RO!m
zT3B9C|36C4{C*ly%+DqkE@Ed(uK#}sheQAODSVkjq#6nhg*&*WhIZki1|OQ9s3)S^
zSI{48;BZ^|$30E!(r92q(mzX)=9c<r6C>*R$lGP;pF@-WIl4prb2%*-i!QzFU!;FN
z0^L`m=O-bX19+~ee=cfA|GbBNZ<izIXCTv8qfgX7UrqYw#-xAl=2_sVW-ZV4Te9nr
z@7t69xs0A)(m!j#J@n67djFlTLH~R<`#(Hs`W3W4oCZ&y<SF(go=mlc&_B;+FQ9Ga
zW|Ir+k$`!Hq1n8G`e#bv!`bKgi}B}g88NAU4k+aMr@j#S=X2=E9od`d{k4Vt3ZZ{q
z;Cb;jr2nUB{5iUCE3)?lb*|1Tk6i0qkQSrWh9ak1vJ>gEE3#iC`S~caatD3v4z%cX
zJV$SYYJXv`-;2o4XOZhKk@9tDYwD+=?1y*`-<54b7u}oW=Tm5asf?h$hy1uZD{_4}
zyE(hB?D=&$n&2Zzer^ZRD64afTjt20U%y0ag!~*_crLSdKEOe6t>x!;;P?$@WADk1
zF6>=Ue)cISKhJ~LTMNtR$u~m98uo;(EqoJNOf8HnoLVT!&%(mB*?@x2udFZ@ek?5X
zE)33oOuoj#oustHuJbzq0w`97;x59GR*Em(8<)phM_xkf`pl&jApeVf2Ij9xKd-{;
z=XoMEPs!6QrM1)IXHHi!^00P@d@a6~wAjNCHClr8=v+4y);z|TuhMl(5s_j(bGaJT
zoser{Vd2mU7kdp-mJ}Ztxko{~qHV3$$1KNH#ArdZ#1%YUj%S3eFK<JnM~tbuz%Ih2
zYra3j9VtC2L7Q(_d9-!9YUX~gz%XCgb2ZKOSeq%Xd23yEWvjKb9QWb)zJfO6psMy<
zZA!rv*ZHkSi*c-?$1byIX`hs0O+k(FI$X2!&vjw{Vtvyx-0$G}S6H;Q378gd0BMmn
zujRS6*AG0j`t~g^I)#JpAqByGuToyl22X>s!43Ht`%Z$gB?*!PmebNjNjd+6I#EK<
z*BX=%?@GC(e9%dV*ySOwT02)j<%+QRYN-1yg0CU1azWU@&T^t8X(+6eGo~&1kM%Iu
z4_rSrw|hh6cBTBgifS(Zq=b74cH<ZFFAlCNR66&_Ym@TLL1jeW)d^#jS$&;S=1OYd
zW4bBE<gRturYJdH2dDZQfXU_GS-o$~NNHC(w64a=w({@lq${|tN%Twcu1Y!Ht8}jG
zmgHaSnouGC)~Z}9|Jw3hAsqlV=7~DA*bGl8+Pd13fAedha}7i&cPi8Yq5Ny_a_vuA
z3{7dHxEgl-B;?<<zkcLV{#)-akiwSa+D}M@7>CrltIgP4{-skc|G{N@tUSv#V{7~^
zNzLJ21N)#W1InGgu&%zVH9`Ygs<}e`)fPg8{A-bIUH(AQl^!uOEH<u?%U5MfeWM)O
zHrKc~Hap$9P9q+|x^8BzZOOl@*_I;rhw=06)e-!4C*IZj24Ll|bq`Cq22-l?@1B?8
z{Q8qRAl2a>m`WE?5%NEZahdWzni4|(UB`~q3EvY6`Bw(>HRq83kjg&fXzi4L*S+?j
zg<}}mY9a1P%#hR;ZSwA8@m&?ydVCw#6)G+6!=TeJ#$h8ULHqEScI1Bo7J!oc@4?*2
zHCpB0)gh%x>!|WSopE|D|JGs7nUue0N*M!=t@%5JRw@7cLPu@Eb^PX0&TME@!z^=m
zaGXiAwRDV6F?A_C0Q*24vp8*xx%^Kcf2C6{VxOimsVs=GGO6T+{Hw)W=XI4-X>_NF
zyO5O2e&oyLUrT$X^Q}zR|CCNOoDy13crbaDp^*Ou%2yj{5pb82`=VmEfe=cVYp{hj
zI6N8N^rr@8b251y+mEDN*F}|owSw}m<o1CYuH|{>TX(hOoJjsr<W&A$QLS{YV7p_Y
zCv*N`{4%J&fWPj<55y|e0M{D%)0RFj<x>8~QvOV49m>D^148~?H?MT{lodUAPPQ0a
zl>Y;Z@;{SVNiP30DPt~ov&dhP|G98DD^jIx`JV+Xh5&UEZF3Fk2<YX?{19r%m~R!B
ztsRQ}b6@7L%b8tt$5%F&6TcTNJ~qk!VZ^m9|MQsjo<=G8_-7B+tBxtk|B2AKfOTvP
zmaPMz@k+1=`CmewT>g(r@_!P!R#1DTJD0h^BK~|s?nvl-AioXdTnC;Z|Hor7-4EU$
zN31b*Sc=sDv&gIbp8$RPF*EH={jKF+&7=G~iysbl!;-#I{@ukkgxLN_iSqBRwLV;x
z(2;Oh`5#32?xRsp`D|9cS~{Ty(Mt=+iSj=#$z@6YM^Mu^tQI|~c?x+#{wI(t<bQY4
z-ANMiuPnB7lUY4c{ueWUIvV-(EyRP7k&yo>P|lqedvZSozK8tpN!~F?(;i9w_e-3f
zn&f|K%fh)k7CB!C-+D6JJcjZYQp$S%x?{&x{+lS}Wd7EG=Q^-h3zrr_ofDZ2&jtD@
zY&zYLyq-we`EAJmNm!0U{x1jmbZYF2RZRVVEIr6|jB^rBmoVddBcYK0vr=3yVoLIV
ze6b&-q~^=p;Qjg}|EDlxSN=B_TW}y)--Y$^gGv5x#FDQ4`%L^zP+R$b7m{`?mWzJG
zEB_a?QA4Ht--x~bi_P-?7WjTEkau8FQ~tk-th^DqSwfy%{_ms4_mDD%IeTmQe;Nwj
z&!3ixuOs^pFo)m39C{r#fHz`MzlHh!`PlV7l6{NV8e;0QpM&|^sq;YE_CD-$SJHy7
zVYz&&4f$82^?=9wA?bS~DGTB81n}=g-o2Cj&!O*y{JUdmZ)8dNUj$8Sp``CxD*uiA
z?LiwVo$|i~`JaQ9Q2viaD(aEY(EkS@8G93VGW9k!%l{!@Fc(YMVCq^<`bkOt_od#p
z<^L?~R*PAoIGUDTkKOpj?3$wdUj`*+U|ZRW6i&fTwI1{~QtCSiU4?Z~{r?W|dmAn8
zjSOF2i9Wd90&b5b`QMS`|6{-^|4&lthm!n1&Z>v7PlLrzv9>Ov)}7cS=4KBU<^Mt8
z?}txsZdLy8v0c3%%P-@d!eZ<@A^$hwEC1SYOY+~lkjwv{u;ShTk9rrB|J#z?_t`e2
zGt2fWJOsAt|B(Ox!3y?lHm0y1>F8Owi&~cz{u}$J@_%aK{~-TI6gFW+swuooD;f*R
z|3k?Cx0C!oLTxRbPpw>jE=MviOY*Z8h<%{QiAYt*PZRZDfYj#l^VTFko0{ckWs;vW
zTNcjU<w<_7VkPNIgwDtM^>5gDZ%^{Gn)QNQer|>n*CK%%u{VAKPS3^aHJDa?jvDVT
z%FkKt$WMWfJuJ><6pqfu6=q`hyO9q_+zVCj&W06c6_lUxg<O7aEy_>7!d2PG!k3Vr
z>Ckg>A>?N`9BS!4+f1LEuvBiyUV$DT!`gKiD+to(re^y56#BeK|F(a902}fw<V*V8
z0(WoBo<WcNJNC^=w|4;>0Jun>@9-|?XS3zte0%mIRxYGZ?}GhnSmESC&q7n-4`4s8
zuo{copR*GRKgy0PTul0<g>LAUeWBb7mBqKXw{h`{8FXC3T2KlL;$16Jv?!}|;~dD`
zH7P2;%V+DBWs32UX10h)0G(WN3yyXKT{nKY%_>C@ADDV|CKI^iv5}|!tMe<d(fVWA
z;%iuVQ^H2(eORx|Wyn!>HO?8K&hfDr`h*DTIumvN896M|60OsgI*+WzIl~Of3$3+6
z>q%XT%`udQ+62Pc7RU2J&(7*_eD7{~cb&VdCM;<&&#)YSy4o~0ux0Lccl;mi?!0{W
z&O2jqeh?Nm=OkK`!saGToYiQZ5d+@^(cY7{uJamlSyU2jwevB<ISsszn3xHfD^KgJ
zbmb!K3Q@K)t`v%O)D-d(mXF*9CdYDqbX<d_X&dw>jB`9?Lz{yxXrmw0lhd|MidEy}
zTQ2|Ft+XyF|4K+M|IQrczH@plmSQfSt8qOTUBtXJ?3~KKwu_KJ?N;Up+n6nKMj3DW
zgj{u2hnBIhifR|}y&!j8DgW;C^=u)z?;A=vz57$Xt*K7_>ls5y(f+^;XPiEWJ2~O_
zr<SLqyKr?S`5y)b!>QA`VCSws<FAna5sBhLkEX6%{w>9wkqwlo{0|}BH-+*!OJ_BN
zWmc+7mFSgnS=*X6EuHtulyV?d%%$F|#@QF8cJwW2qr}GBvD(wa_NApvYorpUbX70^
zeV}tM+8pw)<v}a1Z@y@&&?*zUA>`k8xqQRSxpZ~%DgAxV#T}W$DOvfK$HOSuH&#3e
zYG{)G5!7eMop}974I5TxG#bv>S^0OKsQn}4e-!hP(EqvoyJOI|HX5mYFymU^wyMTy
z85^G<>zRj61+yv8U?h}L{>MQD_f@)^M)|jf$+V~utg6F*Dlj4c?%p26m^S2JyToY5
zJ`Mb|C$^OTJ)x;qt<GJ4M(4`^WXc#zOUmVc3V3QW8P8n8x#Xl4^6$*2a~Imp9r>=(
z#0r2kuLJ)A6w+x6Q~uRB+RDt;HTn0fD)oVOqFnyn|38?LJylGJ_go(3-?whu^PlUZ
zghIO)<=-;{wR%d4a{1RT=Q}Th@qJ@Y+lJ>LdHPgW<bMoxxXXV&*eU<B!Pm2>1~Oj^
z`JV~~?r`1{37g5twjZh0$xliCXMo{=G=kS!Gb+iX@4u-3C&1~D|0UqDcas0b?b4(?
zp_Z9ZF8@b@-9F5xX9K^WDF1sQze^ZFPex8Nc0`2yFJoR;9sareFJ+E<B)FZO<bNKs
zx_*?J%l}bGr_aX%G+c%?ZVeo+PX3Q%j&M-3{I5vze+ngZW9D!!R9Vl=enpc1jnv&l
zYX;E5W2mJ%`5y%)K2?=}<;16zd!BuM6$t6ZrWl`a>du~UTKNx~Sjy1BMg2dTwubyq
z1KL#`cPP96c?R-7h0qvcXYtGB-}Bu@cTj36N%>z2x0X_JhV^G(G{P*TrWYLEkMI$2
zdw=|r{4c{E<gTebONDe0>W_s&`9Bqk&S&Poh<eV0_QT-tKsccMAI;2a68V(>vuNuY
z__GJxuf{3=<{SYn%H{uDW{Z=d&6|?^ucOXWnY(Ams`7shbuO-^c(A*hGSus9kk6^i
zu0NIJ|9UJY^~_NBLV`Y6A^)e*)}z=NRE>K#_C59gr;GCcP3|^O;<wl*dMrEC8u(qs
zu9T0!(eua`^8Y<}UA_E2h+SnenBRm2>;^1f--o_$rp%|2|L3rct)TW#F!NRZukW(_
z?@lQ`6{jQf)1XHq(muIa{u{ZM>*@#h)O#A>KJa8>mGYzfA4yxa-0lev7bf|4hg3=a
zPf7B>0x8{>`UlY84~JSuRzrUB<???rz5WPx0$tUH{9l#ie=X8F4Bp;^{GVMV{>uOL
zMfv|YvUE2Vp!3)pd@Xy6+^?+se-)0rkCUF1|L<dySOagWmH$s-!TB{Uy$icq0h`Q&
zgm0mwm$QFh*ZE?$Tj3_CuKd4{{gJdKSXaKmUa79i|2<&!53F|w6;3ZagZ{sseUA0)
zD*Am<{@uZR50t+LPVZKzUj9#ql8tb)BtI*Q@^cgxxUr-)V(SU{IiHpsK}(dMRaMfz
z7dejvTjl3QsH6P68J>IwEBXNJoEK8_DfGd!;lf<(N_%0?yRD1z^E>eW9sTzh&KTaK
zuzTTq@b;4}^r!OkQEdO8ha=0dInKj=Se^cS8q99RRwaGjoBG#Ebip0;ukR-M+*+j1
z9klR;GWz_Ex~g$Gef|V}jw?Kf{jDb3uP~q>eV)vYEL_OG_fy#Sw|n8Og}K>j1?h8k
z!T!~^P)+$-EW$DqAz|{E9Ns5r*bB57#9f{{>;}d;chdT#1;9|auq`+X3;RIWsNx)g
z$YDv21;ch_E^QoPF>;3EY}lVEuBMt>dwz@`U8(mC{`>?2M<LG09Led#EZ$FX3}DLw
z*WAzBZ|Rn0ytPL-pASa+ok7MtFRW~2BcEg2+{Pt#)-1l^VxNL@zc?u=Z@>GTbVB6q
zcOOb+`+Z~Gb24ndtHQR`)n?~rI`MS9*>?qf1JzNT?RTcGbMEgu{hm+~>%+Fuaesf4
zQ{Ld3bay7AeN1bkGqt?^TIrk@Xrt1`=6pBW>|PkHQnu4ss+I!VpO2n=JIpg?ZT~P*
zJnh+i4yE?HV(6&MQ)6v^?7witpmUr(4XCj|JL(?Gcw!RIlf3=zY?w_<-hO*+%l6Me
z6Ya$_BicVEYb3`EezW+AN9+m+y1VP4AJ}RgDYf6(v2WnHnp%LawS+upL>KLMzS$cr
zqWvR@ot#o#ZJ)=TE33ADJf%C*cZbEelw$_C`A(eYrXNgb5~H6U3A()f`=D2ck>e!V
ze-zsB@aFa(i&i_A=dSHP5MHdIq`jd)Q#1c<|HkI_pGy7v(f<8-he%gyzbBjw0keKQ
zJv`~eF;(!t)c#qte>&}%*`odPz<e%$N1@}U!hhe#bZn=y{rl4X6KVf3wEvLQ{^QAa
zN=n~cY=0Ba_3LQ=de*>>u4w;NjE!vnzwvawl#$SKo&aws%Krms>~ncG4`UQ)`@hHY
z=c9}*n~G~yHMI5LQ~R%BJ*a@ryqOWz$N81oKOJm58OAq&ZU4SdXV2#L&n71Le+X2Z
zlipdK$(TF%e;jpQ&68^`_<tDOZT}l+|D}v0bRVl||9!OoDrPY6=P9qNE9}K;)ll#q
zP#DRo&HwTqf$hJcDE~i4{;%Sx{y(hI9aLCRm|XY-&!*+%-I3tkRj`g)4`TnonuPyR
zP~y$BIOm`EujaldloS6i)3)nb`P-P_#eYIU{C6)Lz+UBVutK$4VGrIw7*;UDcPRfw
z%729Nf6usQ6kL82d!_U8AEoz|m;a|!{!xXz{QNng2F=43T)InWw0jAST!QpIA(kLY
zq4o-hr;7Sadz1RbU+8#sac3^<hb3FN+C^w}q<XV6=d8^qQ2tC)>uUjYl_GxznWH`D
zd@?kxSGBG?{oLQ7CXST$V2!sfEj#YEQhU3a;W<0*?yau<)@N?_fQ259)eZORc5b7N
zr)qFb`p5HCdRDi>AY{I8G58mpR5O)E8Dwh51*PJ77SC$=@6*huME;a+2bgGAAEdX~
z`efHK;CMt@#IDEoVND7CYhQ~ojnM8c4gPm-qb=uu>>%^`>C@dEX<gxeJv!38Y0i;?
z|9y*NfR0+=jyA^^L(xaUfAza#4*B1?4M~bAgN~hCD~j<&>`<@9!tO59;D7Agb0tV#
zI7(svKu4&jw4DErjr_JroLr|BQmbd@{C7+f{P!Fr$0n{u^oNF?yc9aNBP4pJ(T>(~
zcOQ=c*8NhBgzW#F+kkvO#azC(zZ=k6w}byf(aN2}OM6Erz7IMV%FX6^DE}uRnUkyH
zzvn#!|FvW_0yC29Jbqo_f1HCSCmmn)1J)A>qIYyeKcBts(p7VL#>yakE&KAXI{th9
zK{sF~@aqoNp6fC)!H=he&YY)^XbmYqx4}F;d%(Rt6aVK^s@D0AT}%ESz}R92CG3~@
zKY<ZTXKoA@fy2mjP?7(~Q|kelJ1ynEDIL3<|NAEX&xikK75Tp(JDQeu3{0wf@`C>-
zGR|7X=%+uU(9_}n>Cp3pPT@Tr%H5iy$n9FCa~b(Rnm;vBXU?&Hf26(u)#~AcZ$Rh#
zAIDsvGdG8N<p2D{|Cx-l4uyUr8B6cQm~u{M;EZ&0{;#5(wOBe%f&Yhr`301Eey8xq
zAZgCGhV!P_sqE_t{$CAMJfEO*{$GNv@i1%`x3KT;9IPRqg6{8Q47(2gUzzq@b&NvJ
z|J&JN<DRtHj60+Me+>SAx?^BcAHz}-{QoZe|3%{e_jpe@`2U?w;rBwz3`yhC8HxY%
zn)&Ytx^w=Y$awR>BL5e`|I?Y>?4SC-Z^<w3wEim-|BvVGNc;a4@c$-8zi+_G`nIb0
z|6%xlDfM2&j-(R*AHY6%0V@|j>$Lu3n5*1?Md*`d{QoR7hMN-qzuzhRq(boj@WRAG
zIsZo$*qK&1w$NDtdoe2r`d^TCEp95K|8dAwXYNESaY6qpX~ni8{VznStE2z8!dIZ%
z%k0{d{$mQeX!*>-ZUyQ82dt@`x%(6T&N~ACm*JlJ<3mWn57=GUnHy4A&nK{Vp+62}
z_7wR4Bb!wa|6jKwKc(45Yw|jJ4CgGObXUT|QB9QK6TWhW;S<m}_wQIjSb<8=5sF<c
zr9DffbjKo=>Nv_@j!m9Jdr<5_(q5yrsHL+-zDF15#kKte&MjfKqOyE#Rk?kvt@cN1
zyy@fGK<oC$8N|*fI&Qyv8~U|Go;$~5(SE<#)4Kh>nPvN3dv>hVy8YV2`tk&DwYaVJ
zJKu49nOpl>q7Zv89DQnobXL{UIYx1u?E6}_zp@4HgZI3}XuqdEwsbx%obfo?w*7Hm
z$}=U6U*vzZzfyzRes={=Pjmh8ZM5HU%pPb_+dqzRV5KXyUwdTb2s=*Kb@XNX2e#Ax
zv9x~-nzydi6M7uagKj)`ee0+OEXP$;zkqx9Z;#-~Yx}(~cgLf(hwv1eP5WI7T~eM%
zcuBGSD|uS3!roNL|NVJ}4@Rfhe)h|@YJUURdHSFHcYYLBxKbsa$m2+Ua@NS-z*gy=
z12va1hHs77{=-Y4DKw7Nyl&udIwkBw`@;%W%4B=B=bW9|e`2fle=4>A+G6|P-m3kd
zqWxQ0H_6+-sZ?|d-Amo?%zlNH=iNNp-`}eJvy1JY1Q%w&r`GL1j!|Q@{}`SqmF;^Q
z&xosN|Fu~1E?|6kOGW+B{-3fRJKFz^igerm_vZFL*Q))e7v%p!*0|*VKJ4;t={6+%
zkHg|Mf%-3E%+=CuWZmWCMf~pp|GQcyvlCkUf6w^}>sdkhuU7a+`9Glik5T@gT9v<N
zAus=#Y(t@S`4!a_Z`HK%mp?ny)Bf`NJQVSz+z}sn^RyhMRALStDS6qIew1R~k}H*A
zNb61b=7=X?sWx??>0V2*abMDtK2!WNN1i*LGm)o+RVkEXW=u=xvnuQeK2P%}mrsbO
zS4b^JT7aT_^ZC=6$DCnF(hnO|ZZEWCar8b`MFJ;F2-s*xK;>9ka_+Rg#m+;^vYhxu
zz43hXnHlAmFtja>-F?#JRMO_9^)Z|{xJKbGcK=1Y%;WRd9gfDBBeztFb4#ZUOKX%)
zIG<_x=)zd7Ubf4)7;i|seBPe#z7<+bBexj(bWoF8s(1OQ!4icIDJVVt0<+fmnb&=k
zmJn|oTW(&a);Zf|JyOX(*Z!<S+QqI;AsjVGhv0N>`O_L|yR=gItdn9|jDpf)<1Z*c
zAl>PgJ6GnUvU_dig|<Z@jIkv5vc^+1b`HAcXFm79*}B+49hSnd2l|$(*v9Bk?1C<~
zBi@2mmZWG%pKmX=?}B<-e}mVS6{}pfSju`jq;^K%ffRRbE@Cf59m|Ms?7$9wTB7YT
zhqSf@?kJAYm@9j>SL(<3NNPt5;!0w(3tb@JEGIOAxon|7uOTa9V;;F+oPVKdq(lBQ
zHuON`EA^h}qftw#{3tKyY-{|Kd}E^rL}_wCIQe5*o<oipV=iOO7cJA)EKJ@;@0G-m
z9JPQD(Ho++C^e)t+DnF1n|{ezqEciTN?!E9SXa&^*L82Lr`j%~E@f6{ZwY&<xJC~S
zd#nA&vZG(+`p?+lY;ZKnQ96QhaV1N$a}4Pl5%NUMqSUw^YS=z4*73EBpocgsSK_O^
z&b52%ig}Op)gGf9+VlJ3D`$RN!c__B7(B2Qo~3P%>PY`N#_L%Bxqsh29Qw~*6yMfW
zPn7FF-={6<KhM4P{O;J<U#|c9P@|N$mAM|uIoq0k_Rd`YNe_E!J#gv^&o0RIU-VY#
z5N{~UDR<!d{(9&?PvMSt-jx=6urxHz)d_PB=FU^WeHSIxwOt7hj<m;LEz>RapZm8%
z|M?}~(0}ocfNu@!+)*9+&wKHW_Vg{<gM8y(u9fs(%%a3k-R0W=w!yiMl<SwUB-n<F
zv(9@0IRegkPPtSo=|9hW7(uJuojj6MzZl{v3iZUQar`>#Fz!SD4I$p=s=MP&iM<Z)
z(D2mQlK%6QY^BQ6BeG<(ZjXMs{)-(e>Mk{iy&`^I<4LYWM~@6W6S_y)c7-MX*`uT9
zs+E*SM<7zueqlehyeQk=9U46}ST2R-WE2nKqwkjVpBz#)O|vv}C{_8>H~4OeJ|WaQ
zO0jD;jxn4C+uyZOgue0F9#6k0EBdVKY?cw)rY-#PRRrgXCH)sVBlfts>oiVp@LX-r
zVsNcL*MIh)z(pFlDiJ4w_@;sy$mg2;upaSM^6Xh+<hL*EAMVF#kG~^HQUAFM-d+~^
z&o?dHD<9{;s1f{bi2LGwvqtMduK$!QS3cbN(~mp@kx=_rycOd2iv5O%I4ZA}AhkVN
zd>|6(7dpgO3h3gRg2jvP94I~R%6E55jQ{MR-4d*N!1W`wpKnr(=9=rjk<=6|4;#1k
zeYs~VTIxU7y_B{%#Uj^#o{+B`3EdukW0<2WIb+BxrsJt`B4N)UpF}&yf|qLyuBjEU
zHh2ok6zUp7-q3%Zd+NItS{~wTe$U_Wqz%tBHf|!VngX=DR$LPrn<T>Xl*c9hT6%l<
zsm(ma$MMoc>a@2HCcmzv|K_B7EiXFXFOW)p6(jVY`_NsFn~R^ZzA&Dvr~RlGrN9)U
z$z87h#<DLe*ME~zdRv!z=E08fW?_-Y_1}!NqiQPc^vmBpNnyW7)`(4{JJt*L>p1sc
zNKCH(CXmZg)PHgz^xsrUod|a0X!8`LWC9SL0^_;YGq~$PSz^rTh3(SMcN~>)W!AnJ
z&qUvgi}S?QE$R-xEM*^be}3pcM;3ma$9(GR(1ETFxx!>`4gKdnf1kqfUZ!8X@EtzO
zSKqi3&i6IVlS^R=7B9Y0rL|OFi=58{b%1g^h!Pxuc<vM@n9^3;ky{mgo4{31wT@@s
zD8=^U(0}%a21;<(Ts+BqW5tuX+*f3ObiLZI4!K85C|z7ruy`2<=R9{P*MCFdgEHfn
zH8Qv(%p}5oE5@%>g#Od^rt=LT<=roD3`);I*GbLeTDAJm{c^6KjpJ?@HHmZg)MGq@
zMk|>1I^X8fwZ?BR`qpHi8;}UUfisD_u}Il?>{})MH-mQ0Al361#I=DM#$pB9oxU;&
z4EG?`Zv)Rj;?#fcqw7Tpx&E6%EhB)o1i#AS7i9(_g`OUiQHt+p=vw1<Fl9|6{{mpu
zf1aGIrkjRD?@!Ch_1`|M+m6O+R|Ed;AzTE8(-Vzz{kJzI*|R6WZ^wV$Id*BO|Aa22
z9yyg#)PED&#cvGzujbNLzqn)1^BWHn3A=~Br2qCLm-_E0ELx%e4hL#~N-h8~hFy0@
zkYh4$Ecm@<_1}C-Q2!lA+(cFwr+|t2?`YzVfO3AX=bzPo%P1?x0iEf;<H+ZFbgutS
z;=ZK+PQY5K^Q8SOTMT~oz>@wu2wdB9o?5aLn!SP5x?KOQP5N&YCHUQmo}}yn9ZqM3
z^`N5uTZxr)Au$Ckn2!Hel4~ip)*;mGDL?AJ6R<DOVl`d;=N`<H$km8FQ2n<N_?7S?
z^xt}H(e25fPi@~`3;pMNv+mX%1a71F4FYH1Rr0$u+LJx;$zBs*(ox3xrF`z4jqzsa
zKX;(2{~Rr-|Fp)(_ql4x=`M<T;6@VflPAUxQm}RZ7)U;Kf_`u0!x4o~qjCH^4@?cC
z{_}k~^`BpJ5=VQT@3ocdKcB$1&K9Wu{BBaY{?l4N0r=pp`foDn9qYft=!Jeg#dD~7
z(Cc&kH;0<0B<$3G`%}_<_!0VV8d9$Qb3e;o^rb^7qZ?&75Agk+y}0u$P<wDUh85%e
zX=zLScO>oHpPqCy99RD>X_vnjl5+)Ce)ZpJ^v5&7ME!RfI%zR<I2^2(kf#1SoZ95Z
z3UZ%;JgNWA1L8n18BEL}NSxm{IkKq#RwI*#!1p7Owb86)o=6ENQo1Kdork1eNO{Ln
z;;EhJzl$lqr2meF0_wjFSn}7UzIF~}cO!Nm)~(flew)S<v(<l_u!5_>nxJhhBZ!TJ
z4u>MAz~vLt9#i$-*|e#al)?P^@O1#cDsd@2>>^4Lzjf`>?-E)!mtJ;B(tl_2X2r^+
z|88Mj{R*ftmR@=xJBL3GzNfIm^<ZMRK;6)P=Tq(-z#hVhD@XF4$|sS&53@3H1}!)U
zzZZLhj|HE@fZ4{n$z*c(BJaEC*;hdQ%fZ&C@#XE}=lJhxs8bsMy_r_pJ3OuYBCd{|
zL;rcAi>@^OyNNqbR0{p~XmPdS1Mt3W{r73&?_>qzGW=ZsdD{H-+_&xC2ED#Q>we2F
zUiIG<tjzox+Fiq5j+=PH?0C{%g#V%c9)vERqWqQQ3H|q-r2n2G*H>ETzqcj*cL#4A
zy`R=TPD#1`yB&J|0sZ$By!aGvsbsvv_Vae>=hJi=a#IJzXThD_!C>#C|NNf7AS9^=
zF(v)CZ|c>43&GW?o=CQOatL`HS$G!R3^ZQozi~zVHx7!s=Vw0L98b=^=w-h(voEw)
z{}~^eFRta3^s6m>p_0D)@BPM*`p<qf9jcu`*^9wZ{dXXktN)IGcAibQ80^)5i_-XS
z0d(@TGxgv6r2kG%`p;)h1LY0?w?5S5*yU(w68di+O6m(#d-xrOtcL!(hMH#6BS!Kx
za<s4tDVaz(*MHk8^xrYG!}lYvME|`D*?0%Lna-dWEMsRzH}=Pz&pz+@^pPgk3#TK=
z$I(W|f9IlO)PL`!SA8UF1iwuk=)Yf)?|bYyQvZD`>A#zx`Nxy~yC><tOX(--zYp>D
zmvX!<>A&wl>-QrKPw^hrXL;`{^xuzoLsI>BBRuZK303MpHN;A4d4w~o4(B&E?UXu?
z^MroYtp7gTF8zLhwAXMB(oXus9ju9d8K|exBM<U0RR8@vyOp=`LjQd;>A!EX>*wq2
z=_%KLw}EF%{r5b3w0?*Fy8(TZaaz#|aDIw*KgE77-^^0~Jq}gt2*1#Q{+m=dlCJ`&
z|9*{pg#P;x+&!Fk0A?13@-ADSLazUM@ovCh*j=Ok`x_GVAMjB9H>vPf-W~e~`tKC>
z_aBv3Hs^!Wn8E|RF;*zNg_E6T)7q_2x1|4Oat8Y4(4%Ah_eT2f`Q%%Q7QPS-d^U91
z8z~;kI|%mQbCIsissEmdba@Wwc}V6)e$ju|qrX=mQHxknolGlx@jU4V{s$w2XCZTr
zU(Q0e+kZDBo8xJP?~GrFEWQb;vj1-Gp#N@cqyJtD%x96AcToPla47okb?l~lKf3F>
z)PGm<-sY|F`vQ8@BKXvwU3XW4;m1?|eJ^;O!|tg;wEZ@EiQgW(82YV4maj|w_wB?v
zesTS~FHr6G-&utvNL)Q!>cJ`erT$yT8yH{DUIMEazidN?-%Y-5**EC}x6!j7&xRL%
zlKStg!pAtr>wMk-wf|1$ZW`yxk1Rz0ol%JX`^D6MyCDrnqRnR%p34>$8o_T67_^7q
z-<tXRpNYS}f!Yti-;cE5@B8S#zl6VA6Muh)6#kCAg`Z8k0G>|#{c7UxUlV_?r&m1+
zZGX)UuA%h#U(?Em=;QyD`1>mFoV=X<C%FC(yy=X;dlr_Fe^5dF{I{ZhZlW<46&g7i
zZXj>e+(1wE9J(V4@^}Bj5$rz0wo%CWJGrokopk-P6AM?e?!T(=Q|NjEbd|q9guiD)
z#o2{FC;m<^e1URa%IXV;7dBAuWX_zEzpD!E(GT(#ohv~x!j4cL-?3klVB#u#ZZGZ_
zs+1~ZK!xqNmOJetuf;ja30uFR>YVn-Sdr6;s{PotprBTDCAgL?zS_HM3D>1?b+C@2
z0_%MJDeT$WYpQj&IM#Hv+Ql0<LDgzY$n(WM0P(4we%kM2#mhA@OVA!B4XSh6?OcVG
z3$B6({i|=kuv*HrO~re*Qb5aDb<VYGt?02v7uJ5)aH@B5P&nTlPzD^UX;-Mu`M#-Z
z+uGf=`2`-;w_k~O45wXOPS_IH6<>>!d#*fnh5xQY45ChJmH*DQ{fcO{E>`0_n@6js
zr|NnNef90vQsCRgyYbv}AGj+%UE#kc0QuF%a{hO;URT*J?Ygc+XoC#?YqhA{^;ij2
zx*r3a?_jt-r%gp`X}oV-%F|KEcWr#n#q*OrX<b{5cA3}WY=<XLdD?fi&Ub~ULA}w8
zd|c~jAmn$3t964IXSrHb%UmGmzpEkDx|z)J`!Ko*{!gNmk<4QzRtwHZReO*pzPrLQ
z32wS4w)*~G;{Wc+-c(?8Ig@!_wQdY^F!?_XEEc^6{x4uI*B4ul{C7qw{|`>{yJ|5g
z<?F@_v5`57r(IX;w5&{HMQAi*KF|7TVCJyjYvlhtdeL0^|KVNW|JjV{7AO86N&i2U
z5&lT#yp_9F+i%Sr#!({~7YF~(g#X&js^|X^ST`0!^JD2Z(-}$n)xw#K#j15@G6RwS
z=QF2xZT#N?|F<#PK8q1+@c+7hivPF3f5xO$y5RqHjJof@E_H2syZt>~<o_CG@%I0m
z|95qP|KDV;dnf$g$V}-9=GYIz&988+*3DszFaK{${r^m6c>D7fdG-8%w8;N&Fq4x1
z_jZy0zs#O3^8e>>?}OO9)c@Mus&fmn|9|t}k$P$767!d!Tpk-ajLYXWIgEZKL@6%M
z9XU#+B%m%_gmgS+dH&_I3uj8D+VZdkM=nF=$sxTHI*&6wFD-`-KT0*dbLWgFpLtoA
z_fbP>KVsAq`2wE^mt!BW&VYmtyaL-O(-~5!Y;*r>ow(SJ__KW1myC-&cd_0SZHurw
zM$B#AygkmPjO&VvS)=t?qqRAEiakYvK~SYsa_~3mj(wKK#0=8eXT({CyQM5GuHtDa
z=B?HVEoRQhoTs{vNk3}L<tO*W-rWpQuat=$nZi1|6lZY}OSv30_TIhM{#l>#)jDU)
z?!a;m8#7sVspai7*13RlZ1Y7PvCT2bTNV(`KFt|(c&}n@TwX)$fit!`XRWr%`IRk}
zH_mVaC);lww!&J?ZR=xSo4b#U5nEv*uOVkR=8hij>@7-hx02N83Wuw0hnTw;H{J_#
zhmrNi{M(e+Jui)ov(2`{c1QoPEza@X!(09QKF&9g61G{1a*v(VQnrk7?kqK(Giw2`
zPTQ|7Kq`q%@GxXo3rXN4ZozM7z24b2`QZ9)wayc~gmN9sJ#%7Y?Mi;&AxDfAH!+t-
zu>;s0hR%9JO5HVV-Nr>3&O}T7SNd5>^|M<k(mP?|?sc&fGkb#=M6Y$u8@m?!kXtH<
zd#*X8sMZnN7W5Z4&q{ISFRo&5obO!P8pG8(+peT&xrlSj+y(6UTh=F6<%Qh$Ui}g+
z5m))^IlI!$osH7DmKZS!{o-yaX=t1|v=LZZ_4v83N~$PD?skek>YfAJ>CP#8rz`$}
zj~HuFu}$u1RAQArYm~b>+p1O79ih=ytqu{2ombWO55J%0%8X^Ym(#g$uK&c?9RZ<h
z%;)|t@sdNaUrhZMJyRNm{?iVjd};^sR5>{#72K_*44S`M7yFUjg&q>;+_-^KLkeT}
zyr-79!_B>(zE|o#IP0tfN=c2~+R|Jbm+zF;q^tI-ICEB;k6P58@2<3ez5cUS<;Q)b
z?zVPcS?E9a#fA0B{o1zE_eTA8nmg<K4x&22khB|!?;gEso#%ll<DPyO`)A#a?cPs!
z(Mr?72@mB?>V*Dt{xOI&C2k<0lKvCF{DeAj@jHy}&J}A<K96q(c18cWXL1m*>OU=^
ze$ULah(rGw3jOC7{j_!rAXn_~^&MMvkL|E0m+L>v=mj>h7v66adgis~@)%qF{Hi}C
z*vjG59N)sTS1MJ0Q_i3J+?7Um?r1@h;(p68#!T+{v9I(ehcJD?U?}#j(0p-ny!K1K
z6h54*ZyXq|)~WyeqCx0Czm@6kCHG(D`fmuh#JdpM2pib9qs`LY{taNOY`EJx^q;)+
z8)$y>NsXyZvq!r3J5M9|vt`<Ps&(!=%=Mq==K0k#t#!UfJe+&?cDu9C{n*Nz-)r<O
z3%@w&iH4rf=r<OW&Cq{grOtp=t9WL$ZL%$X-%SZtcB^%s)jyWHw0wH%wCkzv6Sw~1
z-1{9k^`HBxL;uO&a{cGK>h{cX{pTCd!)awuE7yNxsllAXD6Lx89lOprun7I<ceut7
z(+DS|R7w90BUe9ScBds{Tj)RW7@S~o{U^0|hZE|*L8SJ;`lS9F41Vqr_w>krwe#dn
zcLKV@brh``PrX|1)pefl=({Zwz+xiUg#O!|m~rIp0Y2)#Nr`sqoS}&))nPb|Hrm#y
zl;Cb|zgg-RA=Q7Ln(ucd{gT2^sHTibyPiNOL+<7mau87R(Dz*Y9%VO5@`TH&___WY
z4VLbgQ~yn(gle4_O{Ruv$do$?JtcDplo(7sqrugk=IXx@#Clq~-=*vemXm0g`fofm
znnI2q<W&Fp9e~}4n~6NC>1NR<>{0eK_bks$vDNFpJ+M&c`fm!@Ilc(}Hx*g&Hyoag
zM;`r}TQ}+(#9in=ck9XNlKztmLntx6Yw2n8?wy<o-a{!x{Wl(nuIRr;AZAjpJD22;
zXI0L|l2;EU#)I8N>hjcizvDTFeiQo7{d|q&RsW4+e}bof^(Frd{-$uhfHe1$=K5~|
zaedhfG?KcefpJ&#pYIhY5tFgZ`SnWm-@Xaw;oMJyVgo3B5ZEdGp5r=;x^{<mx&E6$
zd)x_aKXqSqAM%ZXqw2ps;YkDb)|r&M7uOl^$2SV9b$i0iMU+y~e>16jE;tVaU-jQC
ziVFSb4m7`8GZn1&pl(mmP*SJRKF_K!rUzlq;hhV#`p;eL#_d7QMaZAKrWbZ$ePSBc
z@Nujt<oa(3Em!|}*3o{@%zfhB;rK9i*v#dc>p#EK8{@y>Y2TUWs+xCCsI@N`96~G9
ze+$8K5BA`=%P#caA=L1%*MAGaVjOD|1K5MUgw`AZzB8evy3Q|Z=KAkQsO8@L?yN$n
z|Bm8*47l|r6yv{r$h}v!>}BWBd}uO<H3{{fJG6&qi{W<YKhNoM&*^k1oa?_?NZV1w
zsQ(TFaw_=`0*mfIcV|b?VaSI1Z*R(+!oH*Z`C9-L4`<g)=)dK(s#@1XNs}r0RQkd)
zO6m>9hfvZ|sB$E@9?$wp54d(Xv1ib7^`BotJ(2p=f9}se8G7u6e1-m7i0`)*_an!_
zSi~38zFhwu&JHnS_p25?WMdUPI|NL+vlFW~v<dyUFWAgazav@gISI{h7+7{=H7E4n
zLDaLHT9%UL_XC!aTbR&)p1v`U($s$^gX_M?!zr})2y!pwx~OXWPDUrF|CZo)XB9^M
zcOL5rhr*H5lKx|d4s=rgt);G#{yUkKANAiUV77?Wo28VnioYrB=~_=YCsM+(aAy%$
z&nj68jgO-)^`E;tt8=62VY&X>%<4uRu%Z7JBR`@4jsk<we`kU7@w|)B7e1Br-&*#H
zssH5Wezc;AzJDrhQU6_-^xr1duhf6%le&~V>#IYKT)F-`9m<bD0*BJVvsphY>Awrf
zRe&02Qr9ec!XWCH29CQyEA^kfU=s1u;oB<cz8d{^LQ(%M2b0i$Zy;x`|1N_L)w<As
z*CD~~$v+J~kD--~>_Jukx$pW?=n(qvjoC`lMzKfk2-c&fAy21}Hk>`iS0cfUNT~Yn
zWOku#VOQBydik+%XH`-EU5s=({=1$Q{Ok4KwdlW#z+eFTJ>OH*e^)@uld0=NQ05G@
zjpM%$!H3!Oq7zxqIuHH#VeZ$n13dKKa&o_&-MC%Te{X~WpQeN@tZ%Ici^c4ZTnqoM
z0G|y=w)+@E|G8iOZS+jPFuE@3zwOZJW^hseeURUA>^BVk_ioCZ!mh{t`L4nB^p)G#
z&3z^Kt)<_0MgLur^xuO?|9uGl-Iw&=$0<G6e`{DBY^ne5hCc5{9(%Go_p_YveG`9I
zBa@E*ZZ7J-50WGF-<{C=&GhsEoaXZodg=Bq>%Y&?vh{ppSp9bq^1Yriz7DVa-OFm{
zSJ8j&LSDxn<~O59-bhU!P2ckPG--G6_i1tp<6hS}NZ30l>EdSncRTHPn36tE?oV^Q
zquTDlUc?*evF@-A{b#G6YNh`!OZv~9iw(%nAS8YPlJ~=;|GvTQ)4S1s_ZIcv%}M`#
z5DLGO{&5Ym`7rG*>AzdLsQ>PPB9oB4$+Z2CMg8}AaQ-4%;&b%UJLre=p~oko+D};x
zKAwH7q5p1x(lyBAubcJXPuM^EYxLiTIHx_=e^=2a_1`;bh5GL+<aw@Y`h6bRb^Pc1
z2_^maXQb&yB;_6ShySFkE7?n~{=1tM?$CdKU>~pg?_<sS&y%-)hyHsGtbc_5djMH{
zk{0)*1)t!J2ld}AY5e!P{)_S7>-sN4mjA!4|6E7N{~QOzpWUmF`k2=UmHXzZ&bfx7
zrOo{MI%6UnejZMVDQ}KPz*$Cn&J~UP&vNpWSHnWN)*N-a4q@Hi#|og~{70}#7uZ{x
zYZyAQbalfzOY6shfw;M*(4LF6UP~}vi9T9aV~smje_hRsc3MaNXW05}McYohm+7uo
z#oC&fyMARE#suD$Zmg|x6)vb2YnGPKp37;k?}~&rOv|=L*En6takVDaA9DJKrPEr1
z{_WF8i>c+gDjKUE(nJ0UZK@@^=He+gc}vCHu(mdB*<D!?G`H&pu4svu?Xe|cy><OS
zT1JbsTsi)2AOE1K^^1=!h;K%RR9KQ@so0ktxVpNiz1{T_=^pE}1ln}n7!BpC+G41a
z7M{VSWnSN(a|v;Gb<~wPf39i-rP?3QNqKiCSgN?%9(kelU5Qd&{4#aWN-MFpW7pf{
zhw@;1gm2r0e7cGm@)>)zU7>PCEtgNf-WX*@>7KeEZCp{Yg!b{5kFj1R=FXs9U5WLC
zSj|@6&Ebk(tXjmXsMZr#9ke&L-@ml|*<Mek@Pvxkr|qg|oJ*v2U2H@CZJivIcD}nE
z_j02>r@WZ%x`iu)zW)>FRk#umYiIH{<X`H<Ng1w|+S-t*>i3Il(bN{@XxcL`JR!rC
zH058LimRSVRZ0F`!E;Z0+s>2wmHJq7_B>nV->+J^2I6X@C(61OCq-N<QC|GIg)2p_
zIap)+{Wq8Yf#BJXvRpm(3&x%h(~I$UoUG${Hm;=v&2stoTNn+bctTct&K0jXcgqz!
z*8p?*w+`X8=XyF%e~M84UHz(MRvPl}YD#DFFIL*gT(|Ueo!)7l>KVqyxZB?|s+51<
zgY{cpp7Eh%buRy&5ip99{x5s)0VhSZz3o<LW_o6Nh8cz&q>-E_kwuyz=OBuhrU^q(
z!bnieji6!%a{z7im=k!6DB9+H#2k*H^_V>>#$$y0zH3)?*PiNTINx{g|9-!FEvTug
z_3X9Rj%)AQU0vNAadB;gzpKpl-v*Kv_{U#1;xp!4=jU%)@H1?-CVm>p_TOA=GjEwU
z)&BXpD1YOMpSAF5dA5K4;#gb6$0yeL4RQ7Pa}%7iUYfz$K8Tyw{KPKX)(Yw2`*k`Z
z&Jb4mRQultwV>*f?>^z@7%U;aiHE-j7DgKQT~&VK$o9`~74Q9~+J6`+>xx*o+EswL
zJ>LmZg1d!wh@0)7Ew(jEk)NLKx&8A^2mI}heWB3_chs!Gp3?sLR*){Z|1Q8?62DvE
zZU6kFv@3M@*;pa;vu(^}7^T5quVVY>Dnk(WEqqTC-wo3p_V^pV`yd~Dvx@Tn`yxO2
zkgE3I85-HPeMBn^O}G6so$X+e@2KdF+AYETF5k$~6H)M;M*Q@n9qzb-u*q`j*kJqb
ziM5_iNJ|;=TLCTp*0KqUTtCi1UfBNo!x~p*yWn0@wf~;dF1o|!p8P-GV=@>qH%H8D
z|DAEw8FmKY{=5a^V*4*cOl4R*YKe6hw*T(1SA`sOMZM5sYgo*-x$VCa^{_wk&GtVC
zX;$r@@1@}H^RoSSL7fMYiZJScZ;9p`qPyXmzx=kR_Rnv)2XNoXcV3T1eCqdv`TMMV
zFHT#;!}i|`)(7KiIQB5=prsK(j@bUWo;*5R@-xWY_CFXaa;p7TV%?DKe~{DuD?ROh
zn6&@w-^VCMDXaEB8THu-cmMs7s+o`tLaNyQ`G%E)U`e(A{ZTTFkapHhSF9Xx&6uCG
zWZU>He&)9naqf@xAl3d4gGO_#Zm|6i#wuZR#N@XB0jS&Q*ayS@2w2KN3iy5f%-eLQ
z{U3_sAgn8mMmqTxAg<`P$EpfH>!`&#TSu(jRv~Yy{ZEtjKOH$43&QtmW!o&Idaks8
ze!JrktZ=yPzb4iG$D$UOI_>`mtkjIdD&0V6v0coT_8-X>J=%b3|I^XZCQAE120Hwd
zpiauTTH61?u-zAR!{0>VTSi8LR>DFLl++y5PWJXc0kv0v^sIp9$tagGsIfs<pHl7r
zM6}mBY5&um_P<=(|FKvr8i-UZ#2Q%y>q0ZKrk}qz-4-c7A1PdowVat5+kY)qi1x>O
zyV?HdA=YxN6tn%$miB)d^0fEcY~(f<sXj~E|2))RC00fQSkoJX6{02R-<4=FuKzz@
z+W+ZUqhAP}Ls2dTXo06o`#%ru|4zs@V(pjh|8|t~9a{V6H*Q*Bz3UXLD_xIO#f{L<
zwt3tCRcOzvv9h%gpX8i`b%(8p<xH$eJ%ILqhqV7Q#P?KTU9Jl98xVIx?SC6$>WVr$
z6vshW4b$8Ivse=@!S|rIrrJM$$+rSMkN$rfN^1+qHG6FTclg@>B`Eu&(VwnDUg-bt
zm-c@?YW{S*4dOlIN45WRQ0uDwZ^>3XSbgk*+?Jso--7ks3((WP!7Ah%$jj#_o!jxb
z2EVVr1K)AE5$~kG6W>dJ7#2o?R^nUg*W$bO@9eStKc8y<&*Qfn+5TTd`u>gfzY(qV
zM6}zT(*9pbwf{Kk;6Kv---ng&|7!pLN4I~jKJcHq-%KBQwl^EYsTCu}z<=&456>Fj
zcxS2XyX!+-#iDd?wB7jCI+1#YU*&;!y^N`$jp5Si=bDk5e%^;Rym5ViPdchQd9?z^
z^&53>->^PcSeSp64z7yv?!{dRYFJ-Am#yx=IRD}uH}58SceeK>Nc-xUU#_(<HucP3
z!}irWAuZA#pLAu4xYm~ap4J;HS8<qX-p4Q%w5!&>c<0;jrdGeWLc{0LRr#y;ZS$Gp
zhBvNjaJ_-gPpb7R-WBp5k&=ctwsOu8XpMEpnADN$I}LAKIpA7=s((ID&gUap|9pP9
z;Z4;)pY3M4Ik)Ai2v<3HAGfy~)5`kiuRyc@xgMhKT^ovlD@*EmV)e^FeBP7w&u4n~
z#=fe5{@y279{5bFTmPI{H@vC(Z{gHGpPuC!1>dW@clFQm;;-Da5lyb#s9yr*^Rjza
z|9tbds(=2HD4&t#y+j*G_on`G5mMDZpPyy@^IQC^|9$pw*OV?7)<3^>&$kfp89F|f
z$*0@+ZTjr9s<gg3Q}xgL<+dmR)<4%5y3`Mr;ku*LKkr=m6k$H}8lwbR|C|#xyyfFA
zo=@`i!d#rsUl-#__5W^|-!{C3QBt{>lkJQ0?u0nHBHjOO{r83L0IC1>h^bQUa$4ce
zYVYg6yR^1)%sN&5^EeP`YIy4^_1|6A2l!jwZvA&f{Z}=tjyWTryBvv9ALi8maLmU#
zVV*Vu_X>NvRigZR;|`+~F%6Yfj|k2t?}hpl)KVGlZ>l}@KLRq|L+;H}9;|;p^>i5S
z4ORV5MIG>on1lDa{)b5YPe!i!_Q|$J1nqBslm_1|*U&Z&t#pA?|AWzI7U3z3rD*xn
zF!LVOkTSRlPkRvB%2<>D>whNF9gySR)j!{d#piJ6q3o+Y^}hi1zj80^^J%Zy_?&+x
zKBecAR~>Oj#P_<5!MuO(>whg~^1U&ipNnUE&c#_2Wq8qlRsUDu{z>)!1$d6+zp4K<
zPW^Ag(@^u!|5^X@QUCYj-lE}cJ$nCjsrr8kI_q$+bJSkf{{wi-+5+5<vH$bE0gG@~
z^gf;ndKACicu&LTk>)d<`rn2pKyH)zKM}{5(Es^vw1&3NP+DtH{~zOdjmJ>(=itp_
z^#2QRclcNRH&lA=Jx4m6iBoky;mXt%<?2pF=cMkP3g^pyed=)}cX!S)Rcs_~Y@EL_
ze%>>1Om;U)_>c2qevZpnlnoVv))nRaS>1E+lRS6hOq!p-a$c|I_U`?X8-hp1%IC(p
zb0(bD=bT*KPpR+Ss!!C?oU?9@x15JDef&nEH~oxL&9V3ys9RQPea^P{9VE_R`35KT
znOr&r{IrfUTz-bgb!>hP%K51q1LI`=8H@S`89z^SDO1k;a}}N|ZoIe2lz)Cc$Ir$x
z=bxWk^0NcZO8EJlH-43WetyL7{1jpC!tV~H?elqG{ti9gGsU#>i7u}`zirqWA*jb+
zS*f4@R?u+s&$(p_<cHrLaxL(4HCkr=`8g54S>=u2hDK}5Buc<KI{7b6X(J+;C3^GE
zZ^O8;^EVoJFVo4%Ki{36k9g9YZ;<CNh<NkwzU`i|^Vf}4{`(^TZJ^I@xuo@rA?Yvq
z=iBOAAbdxy1*-h3Uz})$Rb_rdg!39V2IjvXR@6e61GEMi3eWG2-_1YQqdQ_;<~!U6
zq_mmBrr5LRe<bod0Aq@(|LKxiZ~iAc`5%p1s79zUD2s`n_*MRgV0`b3v`xW0MbH0O
z#JJSS|0wVptR#ASU@JWNS%7h63|gO?|2i%I)38>y95&tj*I|X(EgiQ18kEbCD5JxW
z|D{-mUWRqkG*|gQ0x{0T&i2396T5+x-8mQ&Z$i$FLR`%Mc^L81`gb7zvtj=Rq=IjZ
z9)t7SJp6pDdY58^-GcmIZ`_A9#&uf#jK%Y+OYuZ9pS!*XPk+|W|3>70t(N~QvG(k(
zf0h3iocwRcdg6;7`~Pp}-z_N~)wwHyV6Qe;ldDWB4&_DnE*>?ia7{|BOSykJ*6huu
z)@K+}Sy$_7Jg+~FWsZ$^_bS!&(mbR8<v68Ayv$l@san_IXXDI)dJ2o$ykZL6QcY{<
zXB;ayE^$ptJ(WT0T-i}$sUF&Y#q@GjNu`&m;qwh@EZ&<nDvrErRA%lug7L^yab#+E
zg^5qus5K6b9t^L>SM{t~!}_ZHX^-O|Epu&v&pa_N4eRsSD6TIswH%wcMyN`GV>Rn`
z&l|_>^s_y@v*w!@`23PuEo->`_+5Y2KUdjUVqEXzI|#T^!)?#~Kt18ZF`G{xvGn<d
zOy-+&hK4tW=FEhvX>Q8-#1!9zz+cpAXyX$*eDi_oKdgUR<>!Trqv7)B_s5%IjN;QT
zyjSEm$+<$tl{)@yXycrPPifI6M>^IZ*O~Z@cpGVJXybf`-~MA*zNM0*5Z_n8T4{+m
z8rt|Y4xb@nyJ1RH{qy;SVu`Dv`s1(7@jGg)|2D`0>%RqZ!1`xNG^DTUzcpgv(>JVt
zeiw{0C_dHG@Wyuq@VmZY{N=kc*>d?i82nAAy{rE&PW{tn>;J|2?|~fmfaR`I|DEM*
z@9Lj3u1**~S^vFIlI>B7J&~90$i0m?8`}8WJ8dwhV*OX3{@Y<3SM}d<uj-#qqx6#c
z?}VeO|1f5Jd?KSg>b0TzYmVm^`eRMa#_XjHQo!FuSM}c$DQUR=yQ0MT3I9;k-cXbU
zXTog}BcET|n{NT~=@))uh4o*Zs{eAV?F^LiXsG-K!Fn%AC+ol3ssBMZ?}vG1pN7<t
z+J0Dv;rrhYl3E`C3G4p=9D8GLXjAn+1-U4}3~;Q}|DnjsEUEuP8d66orR#q_>VF#M
ziK_l*V$PZUxezzves~(Ae*GVe8Q<R5|FKg4!!R>!1HGu!{}l9p*8c>U*|Yz5>;ELw
z|4I1de-3iM`i~-KC%TE;!?6@k3><+~nuSjN&p>|WpgoK-VyOQqd(c$qOw>Q0@-VO_
zW#IGmgV6^Je7gSM)&Cu+|2vS=Q_yBu|FiJBEG1Z{TZDM_ytTnQF+1UN`!YN+pz8kw
z{PM#w_za%?f7_mwLG}7y2EFH<`hNu9Gm1B;-wzu6-rNeLViQVY1@>p8{x_j5o(BCr
z*WY>g{?Q%C?R}~GzZ(7jX{rAk_oDu9M31`x{r^v_hq3-Y!n)ih)PE8=`vY~@(DwhE
z`v1FW#LjT);sun7+cfY4M6o4%D5a~QcRlvkq5CF|x8is;!gs{+Cg|Rea~`k5k==DC
z&JV@D$gu^He=`B)PN7AIPF=eDxkvI0f?f%`n{a#{#}}|)jq`tCzXs<oVZRpVFJu23
z&R@atHS9Oy{3aZ4!SOBZGqE3obYamoM#pd;_K$IXxWjln)wyO~m=A{E2XQd3yk?$S
zJK?9{hy`GY>m-~b9OJ@|nW(U^5t|Dc<K&S$Wowj7Y@dMe??dL;i5-Y@?gy(~>>@tV
zJsEni&-jcOjt!PE!u>z8$*dd|$Rq0!Gj9CFeUlBDW%1_K#FaX;Y}_7@H7RY@yk)D_
zZQ8cmr+s+ej-9)9a}xImlrKhp9>;zO&Y#5bDeRYHe-?WPvJ&iXA=@Z(<1)yaVIKi~
z*2O5uP=->Tluy9U1q9Z^-PqAqrEN0I@d(Sdi+X39WtiAF?9`zy>w)!3J5D_#)Lw3;
z6b#A(`NzFHbImfcE!)JN7b+}jTwKB_y0*pcgRS#nb366~&L6|^EbPp~1voNo7ec-j
zX}b$M@=GT2K{y`<hO&_|U^!g^#x~A!W0|eSk^TJ@?8o99VPey9{$FlV+sGR8hYguS
z?o2x;n7`*wabr7>hDWi#0oCm|R$+evJK8vxq+&Pk-T9uA%fuixwjBsGLYh2*V|OFX
z4`DwO`QCsXtyIboWhdo^vSC?i^0A%>c#39?4Nckf-4MoJ1b-cIJc#4tDld|!jW}oC
zG95Wx_imOI2;}7C=Gy-FjeC){ZAdHY^<130b?($D(`^K?yLG%0VOBZe(GD_g?60Uo
zTQbH)lRa%O!S1WrQEx`V$<O8tN4GwiUvlT#A2p1N^+wooa;%2zKY;M(U`HOMt)m@F
z-*B!yZ5cI$P8X<Wk>MYPjBSnS;?6eco~P@=3RpS0f%^Kl!|olhzXivwIIhKU9`x7Y
z{B)cjf%D(69|;?~vHy(o+i<)C$2)NxhGPWBY8+WM>#=u*?zuQtI{K9L#yL3{<9E4?
z(+S8K|5FZUSnklLJ%(W#XkXGp{RDP|_vtT#4#K-U75-?%w;Vgu;^c?vk^I0G(<AXS
zeWMWuQ)96|3df1g4%yyrXoK`4h*-L=I2CkZ3>y{}j<~UP+Umb7Mlx)M4S9?`4f(S;
zK8KxSa!*`ie3!XNR~$#+x(xed?3|io7a6W&#kg*XBijMPAiQwK;c{<y&XpJ*amFyc
z<=iQD9Cqky*OWP2;&ZQEdrTAK&!F#3AJfD9hz-Q&#^vTGrSC}((<f=9eb|$|5VFSD
z_q0iUpk6HeV_y<C&pN>v9<Wgv0c=))J=e0N_rh!8za7B;ED<k*{W`GaIIh5P5%wN9
zXM0|ZW4?1e4(Hr)t;zO+X9_PiocL1bp6iq>i#;z-o$n!isW2JROQ!K0Tw|B~qE*M7
zowBSO`-==h9OD9wa&sEx1aotOd3m{c`S}=yLj?teg`rSUQDISW<Hn6kN{Wk{l$JCp
zZHoVfiT|j@Oj|qjXZnsmkd8mGcfd90scbusLVgJLQ8=f+jN^Q7H{_{Fvlgw|bl9^(
z>~rw15qA?P{D9++xTX(ngLM1{=fC2dbMP>B_&4#3@EI~U#(X5!2|LHY4Paexo`>@y
z?DV&2Z!!*HE+^OYPsj@%g)#6*hw`U)Aq?~TH1_i#dlpCfkW;WfhwGPcWFLJ4``fs_
z1IJ@<#C($TEF*y<{q5s8vX5hzIp+sB-i`f3$PgDEr8i<9;rKtcA<x{LL+a>CC=Ub+
zI4Lb{+R~Ypcj_!U-aqFe-5dvQ#qm-cFUOJjX5KboXTEO0k$#HhI}=BgsrXTxV|j(I
zv{U7IDvtC4l%oz}3vk@~Eg%zXhNrJ_(#}4_F*d!}=Vll(Y_Y~@6W`!uC(ggaj(NV(
z0<xCaIo6$x9pjhGi#cvL1!wx^LXLR@$8edi!iUMd*=#WQZJ9g%6S8-)vpsCZj(H%<
zN#<&o;>fb19`nqynvebeuFc6NN5w`t@ByL1=B+cueG`NiA`KVecnNm4U*t*BI~M0R
z<D9-3d3Wni@(+gPL^aN{Ue{n>hwIaDJQ+viOUj6CANh*)!Lbbc|Jr6j4Wmr}!%jK^
zCtqnnrn4_$`z!3c-zh+yavr`N`!?*zyUfAaKBG8)75fgHzk(ynqv6fOD7eQ>e8vU@
zxgK#|hof6&5nRJ>;Ny7pkvrw|GxQH9;5Zw{J#J#SLHk^Dk@j1SV>u#ZU-KT>H^8)w
zBRqDIeT=`KVQ+-8%fWss&Z#p9`+nG`AwG_KhhjexJNm4Q-7ny{5nOF3d~E8kk~n`;
zeGKD=+<Ujdu@m-vuy;TlOe<`8k1~H-1=$f`YC~!<?zvaqBmFtb7E69A9t4WD#a@W(
zX6d8Ybg%PN_*gnZM32dhTPDEn7W)KeyuV^uti#T7VfoyLxbMe49p^J}WZk0;NLo-Q
zc;T6vi@%5?+JX2w^h0j?Og2NIsbK0a#;I5wrz|VvOUkVi&Yg0TvWq~z2r||W<S|~e
zOmUPo4PN)a9>tE0_PNU~ZMqB;toN65eaSn@4vVr<u96O>p&Mi@Q>M$gX1PoGll8{V
zbg({Xhvkk<+2$Q6X8Zwn-9)kae=)Ys#h5)4zG;{-0j&@(*2Ldw*k__`j>0|-eTgqs
zoEbY5Ij;7#c8QWxTe-c!*M5+1B*L*&87q(Rar`z$<J7TpO#X=sKlp|#grE#F=*H5r
zv}AHz!W4u}l#^piX2foYuF&F#`Fr&*X7Zn_>Kqv_TwyQ|lRQ~Ok{O-l&<U}LxEC3O
ze`8}qQCs+twpb)K4kf{!k;-N&(%$gYZDMUvCmrywhy3jj>lte=wTbX3C+}n)AI_rg
z@G~2@i%9L1NsTfze75u)ljDyGLuO84Fpv{$QPMKMe8~Qh5llzcO%%i|HE|WPa;!j6
zes0Lh%_+*W?c&_R{M<lklfvdj1&u?E^K<i><drljYTT?<%T_I$l{9Y>Ds9rLd9U7m
z%PK0X`t=_$aM0lWh7KEE?O0@n@ZYwJLZ;ow&Mhb|%*`tfG;LbaBv{b2phfd$rTNX9
zHSgG^Yq#z_dU6!gHx?Y+WylN!@?o6%!C)a0P}HPZt9IdieN!g1>rkk;xLLF2&0BEx
zn`7qZb8cQz(xge#rfu6}oC_6mHIyDuHhN>OUBJWf-ir5Bxp~3dV16Fv^#yqap%6y*
zqQb()jf;wkiyId=DJdx_Ek$h2N}D!oj{hxM;(x1Fj7*Z7Z#BvZ6c&cD%-X%LvXT9-
zXt3zHl8b*F8tnWWGY~{aX_Omkgg^O>cz=<bUr^X6uTdz!upk#rv7o3)^H!WVcG$N|
zkDk4H_bDr{sH|^CVn_C@pqXpt<Tc7|l%JCqEGQ@l<rd@?@{Xl254mX3vUQtIbQw$t
z${;s4HxGddF+26eh_bTLyl~qSD!`+Fblg&Cxk20w6`-ihHujJR)N--!clEB_=ivBn
z91p|s?f9<UoVu3XyKDDrJifkb_m4O}^v15;oci^86X9@d3K=)^`00kZy4Y+J$_;KX
zbBigbyIYU==u+J+b9gn>G5k$e?b^MCfs2Yq7quMUxZv1e%ox^sNRP@+`%=s>BeAzb
z`exGC4lgP`-5ODtV^41e)57OLJma2SyN&i<{`)>IUk7p3YrA%1S<0io#w2Ilf5RR}
zers_ws*8%xw?-AUJkK6g6h1dFs;JvJjm8$0ot`tcXyDr1Nkx&xMFWQyl?^ZIR$UaX
zE^3MJ)kS=>49XJwGl<7^L5%LN?XME}s|5Zkfxk-NuM+s*DuLXHs3&vO(T$5k8aMYC
zQkTZUMiDu~ZHH{@hDPKllOdcHFP$ydyzS%`R0lk%r?!?3=lILb<v;D(%{zDFGAqIZ
zo=#L-!j8yEj&ps#rLOaxYup~oR^S|4I!6xa-VJvkYO7P}bH~!1j@X?~a1O(*g*q6k
z0}(lM<x%I_O}A^$xz&=70;sTSx5`h%3BTL9cFS|8bKTA1V&s3|PdBIh>zlg4sn>g*
z<5SM@4d?i&bNtyk<~Z%8xpVB|9Q%9P(U=h<28X+inS5aPa8;jyefotf%F6qd^{=Q5
zcbi^2FFbbkN+s`IIjB1xYQqh(q)HWSZ>M3(<g9*bajn7+M>|mA*R_qPP@Jq~*i`rc
z+JzHdrmXUrVusL$F%&Tegapm|(HhM{q^@%=Zn85Z%z7L3YIPcj@V1%L7>&)g8gcrG
zsq&(wD-Ao?s1E8D9*i-pvKk2%EJQHt6xguJkEX=RT@5?dofKEDr6iDhEu#wNZsx(v
zX)afdjzUzpcNxhTx$I`Yb{78z1Kn`2E<hxKb0+b$1HuQ+<tgI$2!}?&oZv<rbAtcE
z-&~$ryoG2~_5=O~dGGR8&d)0maUMVG%=yn~NQ}HPBr@lZHyI@F7sQ$KC(n!XDsphX
zi{~x#c0nm;H_yZQovCY>yy%uc8tKU~<)SQq28ksX1M_DxT3aq6`PVY8MshJW|0e3>
z$i>wB>kv&&u3Q|P&yU)3^32;{Et-EegB6%};bLKa9WM$^rnoM@n6Z_}#map8nw(Pe
zejHZk-_CTlFj?ZU{Nov{rOA3bHUDwutd)5`0<6uSO*`$(XK=ATKMbDJ#e5ux4f&Ta
z)qTy^adBDxW?q!ZMLhp+yeOB8oAPhvMTJ~!$-j#imF5l5xj(-bjrNnYCGtCv3^4xz
zJ5Lw|)6u?it_<Ffl(fvbhMCOUzyR0s)W~bY6kf;d2J^na-<%sqLyX74gD3DR$Vv>c
zQkm?+f8c~tR;Nhcccu91T`>1DMi%@EvfR}Y?q{CPz-iH`_+tj^H*|AT5NT<A2+({4
zus7azVq@H_1(^nW<4q?PuLm~s8OYwa<&@$cyew%cmpe}`nLp1kOS|F9+IVnrOO%1x
zdM7Me8y6OjLsHB(pUBnJ5`5jN6H{buoLF+CVRlyM^Gc2~%r5FYTKos9$LyxA#uh&S
zO|x>OSW2E;{46im)yQSy<l?t^`Oxulx#8sE^)&YV#d5jhq$b~x_A$38d{UE}8S`TE
zdAZ(#*ZjYSq%adwp7@dj%a_@ZYkW06_&Ee2mKzhGLdjpevbGN-Ar=-BBSKpRFmlJa
zhzS#6Km{;z=edZ96k#J3z{sV$5L-;I2y^8xz7l$ci<oo~=E+}tTlF3y7FN<l`0~JU
z$awCNKS7d*ujfZValOM0nUCHi>UjCYg$%j4JtTQ{nH%yqhGed*+>nT~5rnyQ<0Rx*
zH)JPV7B5Dr=PsWsWST~1K$g4mBq4`rBoDnI_n1qC%=HqndmH4ELi|kK1GIbGqY|>t
z4Y>)I#jlc_@J}HdG%}Rrq@RRr@e+wW9}U#a{|h+JUDF<a^X%u`kiRkZ2+7((LUw56
zUFP?+1BASxk*`?JXDku&u9t}2Qy~|-g+_4^Oyr(*sf7H<4Y?eb#j_a4Ia`J7)W~2o
z-`w+_7qZJsB=#ia5<9-udK^plqMsyW@vsPD#Ptqb7AG0UC5^#R-x}EhoO@Y!AyYLX
z+M7oRsnf{ev~xB8=GhxGGM6=Q&9OqZc!{*tb0BxqdKm5AaE*jax*<=*rG&iK4Vh~c
z=Q8a#Jue}nkqDCoO*drH4H+<syRmd{`AI^?+>kpMaz1qOF-vf*4`dv-w}&Lpj=Ld$
zb3<0SAz^(yd&-^TBxKSJ*$I~t=Mip5SpS?k+PXqQ?sP*=W=Qta^=`=KM)5Z0=$_3I
z(ik2A#r0}8<Xvt^{A}mh40+$v5;E$BycU<mJ=q!`_)y3Omq-t0UVnDufVD>%`$Gko
z&gR((H{_=XAUOy_E~Nr%U$gce?k6F4x*>~kDIv$ZA>ltdvQ!c^5;9O7fdyO-W=MWu
zvC<9M-YBkNIv+n%LWZj&ptzog%i;yh+mqJ`iBv}j9P%P{p587bS{)%!L}Gsha!K(p
zqxejg`E#F1$XIoR0gc?pa9Ml>+rkSbrhLeCb%eknD|q&gHbRUM5duX@FF|a<j-zqi
z6weA9!A@IoiU#7`U>J|c1hSY&O&~u*i{S*a{!H~KWZ<s}<X;oW{|`+dFGe#rgY_G_
zxoHr5hGzo#?kdj&@~u_Q1d@R~6G%>!?2YaOau%*q6Ua8&1hTDX0@+nf4P^r9OcP}S
z*<Hz<31m-o<xC*=UnQ2@3FKv*dD|OzI1|V>Iia^V#!qe{6UY|kQ!4aHO`c|EXPF<$
zb<CMjZZ`jr>%@so-X#CfYylsGe4L<Wm|d+3x!!O>6AoYIQfrc2Cs(N%Cvz=+%b9U9
z-*T<ZIGJJ<O8#QT$%&>6^-R48Q!`FZG{rYFCxTKl&Wl~dObJTOI62W2E#^;9jtXGp
za-u1=m{k#`CZnIah`AONQ~``!6B5y40f;a)Pi;#yA8wRoA*hM`#S3x=5V5-ExF|J+
zJr)wU?J*HhIOpkZ$aCC~sVVF=5^|>-@<fK@6!u;>WNHfgyo3ynjW9|~AaLnSVLuU4
zq7gNP-7TcGM${Cx6^4pDyQ7zg-9C^@22)em5fZY@4Y?04ohj_$LZ)g&O<|7}Qs*TS
z`#F$H?8v{G!d@dG&vHYah)ZV*`=F2w8c|c&*M(f75jBPVR>&qV5xW7jXR(`_!nT4W
z&%V|T`6KPBDQu;XEgDf%*hxYj_7aJGjvISw3aciNJKT`Ghjym08zqjN8c|c&TZI&l
zbLv-gq^37NDWpszY6|;-kf|C`Q`ldH)Om@tReXM@N&;zBQ`n9&1&g~OcR^7?4s=7N
zrm&MFWO%%j!fv=!?cWWVn!+9{AtP?c=?pm^nK{P|3F`xKoqPK=5;E$BJkbq#uNyKo
zg?(N^#@&!NxFM5n$kY_}CkeU54Y`9M*-!J`iC1b0+g>JK2{+_#ZpbP(WNHdKPC|w!
zIC<}cOJ@o@SIAVCNDpRSS3@psE;WTcS3<_zkPC4srE;wsGBt(0PeN{SLtfy9e8CNw
zn!<i4A)jzVKE#lm!v5@rOif`6^4a2(Zpcp&z?s5!7Gg|v@+L%0VTTC`dx^w819Hh*
zY6`nZLPp$>BXQ|WVb=<YX+%w7Hw#I4NrO|^k@K*AXoRiQ6m~7v5@iZoZ}Ie1v|~#x
zQ(C54*mPDi)e@$q7De%V0~bZ{cnudtEoV_wElnZ_mp38g@+O`!kmXIarWsJntK*;>
zP)n#)Jmq4DRX&8LYSFYBr$`1@wi?}x2gS_1nUJijmsqT0VN#xhb*uuO*c)S~<UYJ#
z1R>Sa$~@*QGRz_>TN@W6_gCQz53m|}wK%CTf;Z#P&Akp9`CLn}j~q&gotO~;#lw+Q
zkdV{eka+nA*HY}oyqn3hce){~8S+Btoalx`oLoz>>o!Wr;DHfFX%sBRWj@zZ?B%x#
zDbWZAB75bNLRxEt1Cf2q2SPe}iP-&-a^?*`fARqB9+!u7;_lxK`7r|Ib1lU_fp>Fx
z_Ee2<AhJ&yDx}U!B=+f)Gj`;k1ChOEfrLEE4OxxLe6FR~Yu5<bpb-v4_GwoNxkMvh
zAyWH{dxUKA60!Rn<+O{Rf#+I^ebxsO@>)0KHeBX&AhOT-Rmc{Na3HeJD~0tu`(ZDU
z*t=2A*xRB0S-KYum5@8!kS%eU&$Sf$l9@twYJ>xkec91MiVun)BDNXo@XX$PwvaN7
za3Hd;zFx>wjc_2cuX#jBotH=pe2sD^tsIE#8@`Z`aW~`>xRj8)+>m&w4cAian@SOL
zo*kYUVX};ZZ`_bv1C=-fMn2b4>|59h^6ZEkl8dI&bEdl?QBoX;?AsSe$fz5#+6{T4
z8xq#JmSW$zQ9{Pukc-`rH@G2Toogxf)(0iz7B?i9=_N;8(v)=K$Bej^V&C(LgiN?0
z6K+T@h)77hB8Y1#_I-_!FXa8;2(xY!e2D=0TuZSZ=q_ZcOQZ+WOYBd1ElyzVQ5@`t
z4v>&BH)J1NN~tV#L&6%@QtXG-8t4``<iT#p3*3<CKkR*W;zmmBC)|*yGUR$#d&mvh
z-pJ=#iv9S@5;EzA<f3Uly^sCmS3-<g5$GXrLO2lFPd7q&BG+CbvA3qY7J-Ku`CLn}
zpX)0jBW_48n&xvY#eQL&keEg|5ZV8jD<t71QXVH$&e$#ai<oY22G8E@LJ4mi5&=Rw
z7veJi?^Ph(Zx@oIk)O*zdOR&8q>(!?AOw1TD5Qx-&cdh`==HmhmKrJ92c&m1^twEI
zAB}7u0@A0ikWLzTr5L2|I3YbWa$^NZ*<2xI8fh^Dr2Hfy{WbC#Q&4fKko`1r#9)xh
ztwO3bvITRJK$Thp9jlRFnA3irh|Xk<^uoucf&RON%+Sb^VITuqVYZfMAEJ@`sUQO@
zg+w)C4h0#crm*uhvbGP%;02<ySR<pUGh~gB<r;a0I{RHIWVJ??4F?%|kC2l!@=+zo
z{x1nxr;*<~f(-jY$XOcsdl5*)##{|6)f%at05ZItkV`aj!ZeWT0YWxuBtbG_nviQX
z(sU-s$fJbZq>;}?fQ&j#$Q>Gap)ttltA*UHkw)w#V;&H)O(Wlyf{cAtNJ1l3O+m(e
zE#xVU+|&wWe6CCuU(m?v4j>ac2zf;#%R7Ti93tc`jkH542PPdT<b93IVcVI!OvuL?
z=?+<7%9%pG)X1(DAXBdsvQr~pGu6|!3;9_iXLSRa{-%&WG_v?0kORIGVjb%BE<+1J
zW)u{#9RxLUUTcs8I}0h&NP?wv&@drQHS#$u1ZK_>(pn?q2Z9{DLP%I6*W%k1fm!DY
z>7tQE?LZE>QAjT@5g+;(<@BMp{KeS#I9tczZ%X)x8~!$2=08gxdc=1^Vj2mRgVYp+
znE!-Eo}dqnb{1kB=9HPl7N=*KJxoYMBi-o1=FAcj)5vS|p>tO#I~w_dK6Ku>%Ff|l
zJD<@@)ZVD<XrwoN==?{O9gXZ_3KslR+0n=<`p|_xDLY4a?L18%x~MT)0%kNCX*?O^
z$nHX78X3_Z<fsus5*k@I3}o@)LW~-(oiO{sl4F$}jkIJ=mu^&cG;#&~;j&wm9gQ4L
zow_HLov7E&2h=(G17$}er_+Zn|5e%1$glLFD@x%N(GE1yq!Y->-a?GoUOUf07Fab#
zNJJwiP5?P(wvd=cE}*A8_5>jbjl4;+`eGr*9Iu_8^r6SysqAQE7Rm9?Dmxnam_GD`
ze<?c}X~$l2;-AXST(6xRddibpKojjiBNIqYE*BEh$Rn*lPMIJip^*(8Kw`B*jCo!=
zXVHhQIYrsgNI&|}Q!iI`G;%!K&f32#I~w6*QGs<YDm%4aJIz{xoc5Wrqmcl8+vz5H
zUY;G($hGvLXS5NL(8xOa(DnU<81ub$MhyZvbBd6NMsA>;vlb~k8hMMQbM{(gM<aMm
zpAk4`v$C_mYiAC9=(+bPI~v(WA9~))%8o|Xv;#T+D`m$^#E0gTpag0S1d+e^LD#q0
zIxc8Kxos?TtnY++{s;7-7xoj9(8#{!AQw#$5?kced51pq;zdFtM|#P<lRz$6E5ta;
zONP;dUAkFFLL*<%hhBD{va{H$gV%}~fy-YO5?SIU+c^)t;wvG>QZE@nA9`h@Cd_F<
zBhBdBHnkTLTjtd{hdy-kAR&=DFL}Q=$W;djF^=|<E|Wp7ULqu+kwa)Feuj|Pa<9&n
z^r6>WBP6oIOZra*x%NS2XQh|)r9Zsxb!A5*Tl;|g?OSDMl~-pab*|6D+zCDY7%%ym
zIyZC_VjSxwn}>tkI8;bNBgJeXH_a3hTkX~9-U;O9qm`ZGyyU|okXz1Hc8>Rw3+Y2|
zy<XYT$j#G0ZhJ)8Il-&*4ax0qD?2B8Ni{v?9X}{LCwa-P5g>OKHkEdukw4%$0$aKY
ziJk1#>BnBOb-0koDPGbJvcO%33Q=E{#C@FfpE)FdUnL|F^Xj}oAA0xsLSk#Y<R*HF
zdu|pIIn_(9?F@47<3fzJUcx((z<uv2I~uuwZRh^~C_C%CI<x3QA1Fbt&<;-Xl3w(o
z+j<HyPWO^F^lcB05|Yr!Hu}(qYJ|kj@ak-$58Zy8va{Yx4#b!oc=$qP=S(lD2!lMr
z`(yM|jqGIUB%W4w&hqNCEC6}*LuKb|FFBq*^s(QSopZe875dP}n>80Z8o8W4^ohPg
zV&{5v#D|WjoIbRX{Kaa{w}?IPbd7|MoacnE!e#zXRUpqCCnT<sf#o32UMR#k->b88
zI>>Xk3yEsvg-IaKKP@Dok%Q<%U-(c+c!M`KYd??|e-{$dNQ)AXe>7{s{3kW?Y6Zwk
zeT76edSjb417ycIA#sgtpw7#4g%}rjb*`fiedQz}QH}i68|2kXg(NgGbTY_mTZM!#
z^u~5Hedz1Y3yEpuF8a_nJ`s}C$VB#oH+Kt(T;z={XCla3t<dK2aEnIvD+77EQiyS}
zSLbZ{(03*YiE5;<FUUU^2uWz<?%^Qst`QQx#2Z^zwvhL(6cW=&gg*5BdxRu4@(X?F
z2QLYUT<VSO7W&ZS7eeA1+1wrELmQq4<NRe_okr6^K58c<s*xkucK$U$NJ1lZGeJI{
zCM0~hH@2q5AfFs1B&Lx`>?NO`CM2nmL8C!FyIM%(3U6%3H3j+n0U>dXF!zBkUKL_o
z>D3uC7UWCbHRst;jclV2{VKOLNkSvF^r8RmASArW8`~{xJ6{hG64S`h^r7DzC?u(o
z5lq{+%Y;NWdt<ABEU@!TA#shoLLd6wbwZ4*ygGLu1oHiMAyJJSJ_zK8H-#iL@-Sq9
zAHNe4zS<jGa9@z03fiy?Vj3x<5B<5bkfcT~7zpy8VL~EtZ){)o2l-`|khn&+wgdTf
zg%IN!kB<1z^C+he&5^&jmv7V@;s3Z!!bjckt8tlM&=2I#?Lrb7nOqLC>rElyYaJV+
zlXC#b?(c-eyd?AyeW+oE+OhzW8d^dpYMNaIMXvM27izU1kY!d2ifgD(36O0bF39+s
zSL+M<#DKY4P*g+9W&kxZFBFu}(B&bZ9P<uA;p@E-ZW|1gYd$L|rlFVF8iVG?f|44V
zL1&t0?iLie!5iUvdeeNfH7W}ZP(#nsofeq=1Q|DawLYSs3z<^|MK#op4z<ucN>D;W
z2hgJynWqa1-{g((+Mz&=&1(e3G}MW<ip_@vB{lRsoob2srl82p-U#=v0%~G@FDR~|
znRKhAW+5sYp70j0R^!G%O-(N9z;$ToQ99OU<_JLv4ZTdy+T1)sQ217Fgl*|sTbRcQ
zifL%oen2hFiv%S#bOxPkEAvi4k=wix_M&%fZ9XR`uAy4G*EZ%Sf{fd}S_|o4+nW5U
zcb*;9&;~l#c4iwv2@QQpFSd`_Ur_iCZ-gg|1!`|j6BN_XE1iMD=3+rf4V@GO>R_HB
zC~~Ja!pG=k_cgB-6xR?JO9LIv?ShOgUadoz!cOK}f}$E4M+ey1{6SDcLtl0S>S7j!
zSsLN3-UwfytL<ub7ZlUbD*D=P=14(F4ZT5I-OU<7k-NMRhUsm4n8yo>YiKOpZBO%J
zLB`*`TDQ>O_A<8!ifYIj0My%jUQj|q&!Vvh`k0>z3g7LCP+YFr0r{;p@TiRZ#k(=u
z(B+n!EePzGtMC={LmlXIE6fT(aShEY2dXqD2})?FExm4)xlmA2LnDR*^)uHBGVXB_
zC$`q1#RmGDR|yJhsEnOtfcb!+h=xX$01Y%>6BO0Z?h2qm=C^`k8aj<`cd(g{YJtDg
zP~VY2L(I;C5*m7$Zg)R3A}Fb$P#>V7=AnX&d%gKOif(s*^B6&44PA|985m}66co`=
zau`s=yiHJ4L%;L|8g4!<D5jw*y4`B?BSCQu9a#o6!u(TELPHM>1sZ9#?8wqcYG?>;
zjWR0*8TWbf_0e#k(dJ}9VGSKv1vJK7Bq*YxrF6Sv&2@sJ8tT#*Xq<VqpqPf<qT3yB
zZW9#O(C6KOCYY}aN@%EZI?zOOr=X;U&S8t1WELPb@c#FE^L5ospvh(zL17JzEC!ll
z4i^;B&`HgJrkaNdifZT-y4`8!v4Ub6y0IzHbn^m1aSi=Rr*?pOyP$-I{!X_$!+b_i
zQbS+T?H*|UOOWw^H(wXi?H*+A5){_ZJ5zyXnysLWbpQ=rL$`adStTf{p`)3?S>_Z$
zF%3mq107->DJZTXi}iJ=d77YvhCV(B=rA)bD5;@y>2?n{9~5M4^XBUt+B(8~Lr_>l
z1JT$6HRgAMA{vU)?MBT|7iKxCp~nUS%{IFVifO3z0H8T$wV=3$KBU{7YaT8r;YH$h
zS5sbV;28$j?Upx(!hG{QQAoN9b8s0N&<|*Vd9$GKgHCP*9Z$Er(0oErR6`YXyNk>Z
z1jRKpi+%M-^EW|B4P8mMdz9I%D+?n0kk{52c9O+rnV_hK4x`&$Voneg*HE)cprz(~
zK}ii=IRj{!xklOA?zMINNT51%ld`3u&j$k?ZQiGBX{aOJ?sD@LWlKY+((SG=zgD&$
z_S(9)J<v)shzS7dUPJ#G2DHlTC@8L>B0A7x%>4x=H8g>4_gHh5pztGJTWhGb+FYq@
zX=n%C?s4Y%%9e(v)9oH_-lA-2=vP+d3Fec^R>Es*G2QNoW>VSG&}r!Pfs@SNl`Rbo
zrQ1E(Y>s{j@2{b6>2^;s%LRoW_1fAESs-Rk6cp9ac)Hy+<^n-+4PCb%(5dFBf|44#
zhi-SR$@K}e!^ga~4x`&$XWp-DY3O3Q-P6ohl`RcjG8*V~^BZMLLl4vKo?+(o5L=IX
zZ8dELwBGC_D5{~a#sZyb4igmDkcEyFILkalP*Ov;2Z7EuS1DUhcx`=8w|kDcLD|yK
z1NlJbnzssyYiNB-p!3Y91SK_eEM4LG=7)m9PkL>&Mll37n12Y0YUmHT-Hm38o-B>H
zhOQq3bb(nRD5;^GHb57elLUpI^4glZFVIEiLP1dttu6q%*jy_puAz4Z0$pNWB`B$(
z3cB4(%?AX9pZ41NwH?r9=4*nYUL<b!TgvHn^W-ml>zU)BaHZL(7jwJ8Rd^fWLJzW?
zZ8F1xwrJ=wcH_<F5J5XM^fKM<Rpvp0c4}y3XP~RiqXiW|<D^?`eL^1;H_s7NrlBH)
z3tVH~C}^sN?%|kmt@)UsIt{H316^mnCuoC)7Bj-XnZF3yqM>!{{MVbMSb@#6cWCH1
zcH<k&K7w{?X#EJF8_jWoil6o7D^Ut`lQ~aNnTEEp^WSWqB510HUT25A#k@jLorX$V
z0NrZdBWQz$uArB^&D<eqi-wMA0(86im7pCOdVD0%9cB)O4m_T$p>MhX-D!3ZRQ#Mb
zUq7)MZ!z~1RHmWl**dqHGX+i6&`5fdyUgW+>NK>e6VTtya|LbCQ2PUc?lx}{v_(TN
zvH{#<J}zj7hUQEJy4QSP&`u34W-Z@m{wk>Wd2hZdndSS<rYK503az2)@jwrleFaU`
z(9|NJZRU7EbsAdBLFhrVR?r3w&1ektkQo!SMMJwe#&0*T6tqJ_@1WTR9yae4v{OTa
z>A4;;UlvsSf;V4-CIKbPe+w$p&{l*CJZk2mOXC@D4IRVQ`<S_}pgIk$K~oAmZVnZ+
zK|{y00X$(IENF{{?q=(K(p({Ehla*h13hJ)CupaJ4(bT>w0X0j;upR7dXrPbXUr!A
zm1(F0d*!p{2ZE+*Xk{_bbLMY?>NIpk5zzByGt4XD4>j~mSD+WnGC^B3G_4QNi{=DD
zJG@BT?tIE?4ZN;h{^AE5n@xbi4)a7&F#h3WX(}#5D@uS~HZK(v*U+6vaNrg5E<ur(
zyjq{r?Y?ThC@86+L+N&3Gd~v;+u_w}9R_;cv@4j~@XKD*1s8!g%zXqUG_<fg(3|EU
zLD5&dT2=?3x6B!Wj90ygT@c^uSSBd0p}QLcy<?swDDs+DYvXjFf11||N@^(13Vzp2
z2#US#)w%(B4ZLUmQ&9K~FPh69{=WIMpoE6LrrZ6%EU9E^MBnskZDzwwn!N-WZ+THC
zR?3Iw7(sCj-OvQ+BXf?R$lG46f>A*KGEWke)KGi2vyaWo1jXL*Y8B=IePaGyQ23u-
z^e^_hPtAV_N@(aXy4}yrF9b#3^=jQsxBIynfS1CJ|9f6EfNu8-v%R3WhJK(A`qCUM
zDDu8n>-dR4UzuF;!1P%|n^?>LHtPh%KJaQyV5NL*o-HVx^rBDbcE2%i5R}l+BKFm9
z%|``AKlEx{30YvL`K}=2BQJW9Q;qM;{|Jg}sA34v_hu6~72Np$%d1sDfA@pgTToI%
z2hi>QXpR*W``D{BeG<@5=3GJHPrT??Tm*hLPZpHW(2b=)|1mEY6#dkz^%C3sFXr8X
zjL*F2g_%IVnlA~8Yv@I`-rvkG1w}shYK5l({cbkuFZHFNWgUV3FvEgkUwE~GkOlrU
zhX@LP=|u-Hg}cmy1SK@onzg*!JX%onE3ekOZGjBy96`pvy{Jn!Ak(^0P+UVt((PK-
zV}c@Id$h#uzDIej;eNdUzkWQXITUiNA4DPPDm;zL&?FR2AlE8FH-ant#)(VN2y~o4
z(CRKIs-X>ZG<nuYL2(UjodJ|@)d)&zXzl?(1r`TN*!tFME1&fdvMyG(G;~%8P@%O&
z+0xLyy?}}=PQB3UH1ui@pvKmx%GOS=twY(hiY>ki3;s?+t;PYBSZxKxH8gJwP!nr_
zprnR6@$RG4nl32(o!1s#hK&!AtR>2phAd8Ynpx|WEe)+^hiq<Lr)+8H++v^>*2Buy
z_g-5|3V~W$Z!23GTEK#8W&NmZX(-OpXl*qfBxR_frzQfmv3dv!|KPPXJ`B{>8YL*I
zp%1$PwX>pv;u?Cm3D7>)3Cfm+j-3M3-nvBD`q69aeA)_ITa_&h?T>JQ4%Q3GmWJ$7
zpna{+lr0V6dyV)I$zlbd9scCCwVs{7lhsa8R70OM2kLAM6cpFc3GCrrtOEokHPoX8
zP*-cIvh}mq)|3N*x>;u`TN-+dsJrzyWlKY|IbrN!J)&%BXe)=wp4L0c)_=UVZl+c*
z>nCMPLvM3P?rjyL&EdvhLuKp^eXO2>k{Vh~)Ylp<DEy1pR&{@%GHbS=sD@tPxLa<W
zsBCFyDw|D(b*ZwYq0v2oDy_SetzW&i&LgU_UKAA7(5Zca`dOa~ifd>~2&lhh?<Z|u
zL(SPl2Uz<E3jgM{_0#@91Fb=VqFy9!cLwEjyXqSW`1$X{*<uD;M~Xt+RoEYwAr6g!
zA=YVvBELIk1kI`h+Rus$N@{2b(>>IBP*Cg-uh!EufcCfE5ETB?i;g=0Xqfe#poE5O
z)?&m84P`+@cX_ogpA0nI>MF?C?L~v=O{%SGL2(UzNw+(~;?wz<N*KcpZUvIB<#aS7
zt<{2(8oHCVMp+jMikV)m6X<qFTXzTwTV6Dz9ncu-SwRU6UD_6Cto5;=sO{BiH5h1|
zwObH!=t<%EXexp6R%_HVdV+@jRtz-3>L)1D$g8!EZg-+JRZvnxC$pd?Sw{(q<#@I3
zV`)sbP8Sr;^`iGC0!^{55tPu->@d(&>mfnWpjYb`_Md6in}UoyFXB_df$7%wg5nyw
zgKqZ#t8kdqSH4&42HKiobrY1-(18)41FaE)Vg+8U)^xiESw{#8hrFl--R?~5I6(;w
z@zcJ*!PZ5BqJ>_qKiG+8S$7IDioECoy4^#p=LE$yG@NetQ0o&xk;Y!F`3C|WW*Nu>
zCJh>Thv;ytji6YuSL--B&?Bt=g2E+U^lTnbjWtbBLPL*ID{3tk6m8<w`i^dQwsnRe
zqtuJWvRBTrt`!v5&<3Kp)^<UWre3W>=yvB>ZwX3j=wrIwT8jfNKHG2R)mq4AGv8w2
zVJvL!MMu!LF0i@_N@(Z?qJ`E-LD3dot!ea8i>w+!MoTYxhUiG^ctLRu^<fh|%DPxk
zq?K2TZ8Nag+9D|FMdEg!r<`tAeTgB6l?1k!rPha{5Nqwkbq|iA<LGvmS$_yhYG@hV
zZk^QvH3rYs#;f&kIndEog`l{G-lN-HZcP$owDoG8Pq(|mS|}*0p+VDtR$6NXB{UQ-
z0a|5UB`Dm^8{t%XlVhw01jRIDvObQrUK5nm(0Dqv)z-IyBKvqFe3x$bI4d8wF7S66
zx?l{@@m6O+MtiT;bh_OWtcakfhWM0P;6&?CK?x0&(e0jO9U~|l_C|OEQ+TqqQBX`n
z+cA3!oMPQ3D5;?<>2_n*(}E%$yb)f^f?8vJBq*+-f6(ooYW*q5*w?G|<3ymfR?Cqr
zji`orKM+`FRSHUIs4;KTPO~Np3U~BI_;0r9)2&5<Vj6mqZubmpouH(Kwugb%TUQH;
zbn-@c8k^{u);2+L4V9Myon^f)$ms0V>O;4CwzX4GR73Z61Ukp!q70sa)zAUGfzGwM
z2nu)cM#vAO1Ls-81;sRUFx~F?)?tE@8aj!-b%S-Rph#D5gx?cwv@Q@7*U&~Z+rS0Z
z?ShPMUM;?&CUBwkjG(B7-lo<?*1rTLG?X_Q=wfS^pfG(KwgPbuQTo<PtX2pCFR7uM
zh%U9N1SK`JoNo6rYl@&q4{wBjbOO5EI#N(vLovGDE3DH589lvP$FMJ7X~hLaHS{pi
zChI{#2@T!F+3sfR4ME{v-UyR)yH{D?35scGG@IzvRtUWvW1)sR)9uEsu7V=HJrRoA
zt){#dWv9OPfOof@Nw<5gb+9PJU4>q_44qH6d!4mHP*Ow1?8bky&Jz^w<Cqbx*XVYy
zw{8{`)zA-gyEj-*2#Raydb-^ktq+tf4Naljy~+Ab+3M@H^%Py<%~rFqEQqLvKG+xN
z7OPB9Tth8cAGcZ)1SK`JAN$X3)_g(XGOw*XcK+L~HOiKTnAgA^)+S|3L+$BX@3ihy
zwlwr4(H83!Wvkq4YYg4)R_kkJOGB+X0NrH;(X`?HHS`+Y?%%DBf|44#i}iK4wZEWn
zh1b??bi4OhvjjyobU*xU;9hH`vZbMdNkI2m=PO$ps-)Y!-?~NFs`T0#)(z+Z>q%ux
zLz~+GZL^ZfmWJMC$v<fQu54-OwJ^{_R&$IGm<LsPZLN&}ZMVt=MKv^*ZuenpqM*2j
zM$zp)Vl5Dq)X<A`y9w)5Wvidp){$&Bk6N3REe$2Q06k{iuWV^(8Qt#V)~m{vhAyIS
zeZu-i+3N4Lm46V>lUCjYY4aMox+Tz4RwqGm4gH!2^t3fhP*OwR(d|BC9U>?^z-y}m
zoKN6cYn8I4p`Y2mp0hS6TN+BBq5{ubw<=p2I*V@i1?wqgYoOOw)6PIIS|2J~8oI12
z&_Ap{lr0UtvLDb(RtwAm;0iVLMo*v}R)wJOAg`_G=yqSWCJBma=$8=CE7n3maSa_o
zxBIHKR!~wyL+N&3v#t^p9_+PsH6835)&qi~F8T@$H*`H6?3>nWf?^ul#7V<j*0+M<
z8v2qB_H8R4JrKjchVs~K-my9hN^0mqI@o_&5kbZfCxw!XS~}QwtwRNcHS_}=?0eQR
zf+89!Vt07o+9)Whp}s8n53Jh+#Wcj_r9jepT2Nd=VRrKmEq=KJ`O;8=4)!DKPeDly
zEut6wm(>yp#b-kMdGj^6575U}rJ%5eo@B%R#F{K9qM@=5K%ZKR1VuIU6&>tn);d8k
z4Lw^3^tpAlptyz}?*;UQwM|e$L%Yzw17BLN3rcEeU*t9Lm9<llG1Qx{esq=pwhB;Q
zaC#bAK?nP_)kRQ5Lw8f_8*8|rsD^%E$$x7dCMc#MHjuzhi|f1?ZZvcS9qf131%eV9
zs-c7Z-nv~-QbUK)!Tw-9Bgoj_o3D@AqJFggB`B<+e_|RO_{rKOD59Y^>0p1hT1{mN
zqZ&G$4)#A*m7ti0Ze>sT#hM~0uAzPDV1Koa6qL}=eRQzDS*Hm~YN#Y1=yxkF$Qb6$
zS00DaKdc7@g*7yl?eI_Q4M7nNb!KVovc3}()zDjXu)D1g`Yoos8tTvPVAx#+#WmE6
z4%W1*1tm1Jg$~xT4;Pfw(Cq0zw!K=A5%K2h8+P-6eW9SRh8Bf@8rgRUifCvJQI7qr
zps0q<ql3-0KNb|z(1CQYL3_8LxEIO1wlz{I^IG+&7`_<Mg&i{AE+eoLu0jBpp+epY
z7uXX78N;0{3A(&DP{^JyD59Y+Inor`YXrqKv=6&hk-bS!LPKw{Cp5P2Q?{zTww~b#
zT5P|fY-#9udjAspYh_DA@0S5Jv4e2u$d`tiAof71-BFM+!fR_cWPzsk{(>SJ`jnld
znLSHTOhe-b05!K)3QA~b4p9r6t0i!|Tv5VSAZ2(f`)W)37G+CA(GEbZ>?f5i4fU)9
zYHcS4B{VdV-oK6gyC7qf*H#ZY(6)AS+*n}wM?*icC$zK61;sS<J!h!<*b@aMG_;dL
za(jD$AY-)G)_XyquzjksrJ=j_0qS6HR<<;B0Sjth`+j9hL%lGc33RkyRkp@>ZGA}J
z+R6S#+0sxaHqp*DhkA5=4L!*ecCkANN@(cRBA~AJFhRyxudSmv(sZ*A5fstTQ*3PA
z?N!Q_hR!bq>S1qCwls7*omx+uE*5QLoY&TSSj-OevY%46G_<l6P;dJ~WlKZfvqkl>
z|4_Cxlta(e*KPry4O`>Aw(eq!DzhsDMKr{l`arooNl;8fgXyd*?1h378rn&>TWPOV
zwkCLORdffcvaeFMG_<HMP(S+tWlKX%*s%NCuPIv^x*Ze0zySMOWox3>R!<hxKs$e?
zw0RAU=>Rmy?kp&#p#dzY!Fc&4wGtW{%8_P>eW)N~lGoO+tjhiDW0Wl~3f_zkzmak-
zC%CUf4E>1@Xad#tjiRv7RX72cp#d1Y10(In1g+H2pSeJz?e_%5yhzOaLOIR2Zw(8z
zV>=pW7ah#p#9f7t5Kdlw+MRMu;Y}9xczc*A>~s}MaVZuKaTVNm>V$^U!eqNn6vC68
zLK#Vg3z3queF{I&!W8=&QHW1*6jo7zMfH%Y;J$GpbT};>V80>?##Be)1}f0P*FJ^D
zW1%p^wr4TZ30L7wD$v3{lrz)r_pw7K(Za!Yl_(g~91B5QiiIgYg`Tu9%dQoLxT`RT
z3bYW@6|j0VlXZHieTgU}U4<j5z&vdADg41<`7rxwQHV@;l5`~%XyGGQA@v2v&CEm8
z{zVj`uEGmcpoP*yoJ^+_lC&_}?oMFGU4=iP5NgAz$6R})poEJUSEwcZ<2<`Yka2*M
zE^0}-j(5$Zz5%qI=~{@_Fw#ueRhWlMN!P7Dg&LOaBKuKMsB;xA#%1U{mf}(NyMp2_
zVqBprrfaeNA3-}^L@h~IlS7^Cryh~-$!1t*cO$UFGn|b4K?RoA2%o}1-Jo!^JxdhE
zx(dB<8Ok37w8CB~DC#1{6^eBST4|pzXuXT5CF#0_a<;|PGo&5*Lt!;u*T;0lU4@IN
zz;yl7r!avQj<dfLh2()wMxMlF=#~LMC)lCG7+2&V2QjYD-PAhK?kXrY)2lU-!|lm-
zwV<SnMC;G?K&RM;3kuKjXi08XQ_kEdH-|^F7IN;k);>>}aTVs^QgU;%PoZ-j6xP{~
zh{6t6;X*3hjELWH6;e+jtfz%D?46=u9O5MD2`aF>3J!OYlu{T@3+wF;1a{<5N8u;e
z!hX6!F8py1D4b<a7lpX1&;^%bVTn&+Lje@dw%3Y6_%O%9Oe!!BSLq6<jC)I<aISr~
zC`4R^^;BRUUh*kC-v$cj*`J8QR9E2vD$s&)gp=vihlV$?ls4MU3GAq=@TF^^+^29j
zOX&i8j3|T;ck<8%mttX#u8;!{$5Oh;UM&hyS79O*n1>5}3VhpS;9~n`Q812hESy9I
z=HUrfA+-X3AsxdN_B)~waTV^M0xkUHQ#g)!xY91DVWu~@3LhX`=vbz9v)x5d!bOZL
z^bFH=l|5WgagCEMYDu~dqnvGAr3-gZZ?N{__Ht2(xC*0jDd{@br|=nT?;86$QK)kj
zj>To@dFJtN_QQf=E)vgsF>`ah{kEWli^N}F%G}&&|0pQwBGLMoxw*-19Az1VqfTx_
z>u09>7Q2U_h>JwaZVPm)JxWl_MJX>IrJQAux{J&k4~0AIV?-hDDvZaal)*-y0^jO@
zm;K);3Oike6L1-7&fILZ9}^Uw?If9Tg;rDm-DSTgsLn;A^*ept-S#hn;w}=ccR4w`
z$1a`CGT7-NYRNruH_DltRz~PlR?Rkhe+e3%<JfMA%g}vH)`RveK~WcdYyyov0BF0t
zQc%oAqLtGN=wbVOK?xU$mcdarVc#Ms=_1j3upiK)_LG9bbB7~waAnkz6u(0`Q(S0-
z7BIz6B3sN{#0~l!E<?Slfu6Dp<`5m`BEBm>G?7}**j)tGxk$8%sr9TqT+lf#60ON>
z7SG#<35vT&v=;Mr;060wK@YizTG9Y6pqwdAO@KR&g2F5IO``Cet8gMNLqmyPvmY0<
z!$q8fhGr7IVZSfPm^Yl|Via)l7&@BhE&EqNQ5SL67do5h9lPmV7DU`doUVngCwkZJ
zD`<y{q<=g@^u9e_P|`&*5os|5C~4OU`rbt{7dW>S&_{MmkWuTTP=@1XygmEGzEaRs
z7jbM0_2dlVQ~O>)F&A-A3XP`LXZFj2k}jer4n>JRxBo4uc)nvx9Nb2tFYMfT%yOBF
zBwrUy1p3n6S5U-7><)$eDZEA<ad%)8oowQ?(;A$j$m(X}h|Mf9I~SD}*hOuMO3Ws?
z#Vt^w%?-O~aKVs*aizHL=wuWW><<nL&S?<QG=>z@Z5|jZw~N6;u++4R3JR!e;xex=
z712P1&UY>wjVtA4folfYHqCLR)F|wLc=`es^)ZLFQmN?LiV2IfyrjAngW$dYc2K3x
zYKb3LsY==4WeF}lw24DulC(4(cv!3bP_0e90*3gjJlv`u)+%dxq??4>I?yBnZgsLD
zG)h<BxKge9a`XzyEkFZof_vbg+XV95CXk=58>XZ{HL;K*b!xOQ9Z1z^kyju&SYV?`
z8{e~T&EJa(@z+F0FtD3_SFKpychS<hi&xF7HRNLPqB(sR%$?hJ^}zl${i}K}ubsDW
z_R8Li7cE`2y083Dx*puo?K@}D$`wYRK7IT2QGap5|1+jcnRtL<%w0Nl`Lek+3u>3v
zRFA2snSIRaiazMzhOuJhJp9^DpM^{e&ga$6$GL^y-8`<Yb_Gt6at2wZLLhDK>C)vB
zM@}6vuXgUTd9}-HpvTYwC@xx3TeGBgHZL2|LZ0RRRCMd$#^5oA6|izP;IFwMCwQ0D
zqck{y7db0)J`G+SyxQu~Y@J+h$ho@y(Qa&YGlSP62tx+rp9i-Gk3=AAJO2bv<6o=1
zsa(Y6@3l(QOfIfTi-K})^=K}<%CAzDO{KSlwZ~(~WU9yK*!x`-yvADGG*}V*DR|@~
z!PBhKO@r~ESiV4_ALWV5UY%Afq+*{^yCyB_M$z473l-URMAolfWRYx<%@4*I*_?D_
zovwoDJj;nJfyl<BB6~<uHac5mPRfo*N7e(8+4<Ib+f-?L7}1SnbW)Nky75_}D{`WX
zrlaesqWd}EM8|TI=%n2C99@QT>vC1_>IW?g9cvz%;Qv8gt^9wutF3DrVV^VhqN~OC
z*wtD&U9D-VtJ!(@VR!T}J8v5g|D)Y)WV+=%X0Tb$kp9LbJ%*MuqF%cmm!%=PE$6Uw
zbUhi{-DY#PYB#$7qR&YO_C&{S;`TW=y8pJ<d7_il{bsfDrmlW;WB<#{uD4rzqx)}r
zohNmUPxwXo1UI|&OK;@fr_YJd@d|E){~IY}`Pm_>mv|XBzOn!7tp)zs@iW`e$t>eE
z{N3}Ao^?cCGJDZd{}7yURK;+t<TZ;|aj53->=|V-M01o~HzdLnEYq87t-CBKbs2zy
zYo))Qg1;QF7S9q#iKuFpu3A#PbllSFrDK*aTUED0rUui?`x!OM7SF3$Hh=z#+Lgw<
zWvk{at~F}LO{p0@ZsI6|dMj4WUcPepym`xA&54VbL%F<WdU>S;K*XcwEvQ{FwH85~
zXe*5+vsX`?IK5waMNMtpqJeInoT&+?C77PnE}y+}+47p<2OV4?Hdo9(rnaVb={#e_
z!ez@>hWX2YD;6DJTeEUc38_Fr`bjuWW84&tKvqX+S*=j1^<_up1(dlycKM=}wKa7s
zmm4+n7tda>!i}ze2A$w@R?V-OGkXO}Z1J+WM;XW0E?>5yqF;ZN<(eh4mmgKTe1$Q$
zZdJ|v<+VrGj2U};=A5KTjRn4F-s%xDgBw#`w#VT8j8!P2fll%G>lamobYiYJMQV4P
zDvm7E!#z|rN*M9XU%YJg9xFnbTfA)Pg0TEy^=Yws>Z3d>K}(psYI)7vWs6rWSt_B@
z<)LaYeO*<LqcPVlQ+1XOG|*GAQdg^%u2{5SY3;o5+=a7I&nr-gMh$yF|Eg>)P1O$y
zA!B}wWlL+*)y^QOi+T+(-Cfct>u;nBE0rjg8mqOk0*PUhRILc<WS?MKRnJN_v&{C`
zD^!zSUORi9bSftxoq)F{RKQhBSFNa>S7FRwI(vz70HVj9;OJ>x0NEKhNRr1cz%J{F
z-E|bHQe%F~`y)T-@3kw~xt7+hM(%3rX5;;sazM573Q6XnN*(&SvDUYp#q&5VFuT)I
zrIIN_%8QU>aS%>+m4onP*k8}|4f7W*u3fs!@nc%u)}YlbT8jLk!J$ONWu&|$>wC`Z
zxks(4Q*LF<<O9Pa!g3=Rt|%+-SJuCxGTd!C+V0rdE0w%=<)H52-b;9shr`NMOKXRU
zXI(Ux(&cj(4#mA?@BUTc-V4ILad$U#?jTg0IJXM7c)fWrYL?(8PpVd0fOHwB#Ju4g
zm!+yGOPR3+9<y>bh7@;zVNXfrc3E8=nhx<iu_x}|Yp>pTr5c^5p?R9|9_lYOUZDyz
zXGBHZcj2-nwS89{*Vnnv?dy!gE0-->yrOS<xMERDdg=2WkKuQ|T2u391V!USpBfU&
z>ko-cY}#9ttJJ3j10*-;>p{9_Pu-1pDu?R=)#$J?d=DH{Gh#AcPcnDW^0@~rTr_{B
zhz}_r(0@<zsx0CAWs&#KA|H@NJ}`?Mx$~s6qUI0`vq(OM$a-=(PQSdo=8&qYJ<10e
zbCynBwxU`_UR6fYrc_yEXH|R9>$eBie-BJA1LU>5qD-ZuUS1u!UMK1BdYz=@dYz=@
zx?Pl6MO6m7X}NAUE!XX)<+|Op+}9QyyV=sCw*|ygK9I%Zi>7>#v;}_?S8`wSo$$Wo
zJ91z09eFmpzT`XMvoy6z<{?XS5|*Vo3Cq%)gbg$nFJ4}O-Rb_E%)2fC3x28Tz2+S%
z9MyU)uAfR|J!!>2sQ|q|(XJf1UJ#I1s`jkQS&!1(^zuvx*XuDY_nCE~*XuDIUav>U
z#WVP%S^S8TCp|H2%c=}~Mk^$CJveMCu`lULoFx)}5+&||epiAKt=y?VpX-uYlIkzn
zS>`xZqwse>Rh{*GG3(O-x(0IJUn<(K;MANSVETyOp_d{Jh*&Shlvpptlvpptlvr<d
zDY3teib*|32wf#Tz@P8|S(=e*>RH44;&;MlkY{LLOnsTi{Y9hX{<2YWf8i*(zjTz`
zUpz|gPp9&^^)k$kkikc%#J=Q9qplYTb1Qzy-#jw7t5j%z5lCo%35eKV03!D1U&Oxb
zt90vP<TAq)%#~tIBa>^!q(t??ss?!f2DqMbSgq`rxh5RBUKQ!^dNHQuzH-dyB+}va
z^q`iq`HoC;5=5iKzEmo)FOh2Ys5clyqQt&PlsHQydPY-``17NZQm^qM{J<>E(3u5c
z;_n@9Su&Y?3L+XnA6YMc1XnX+J+CRTp4XIE&nv{rzxg6jVqYXmoFx*yz*2GhdYFpD
zSB^^TE0oGCrRd0g;WN&uk(i8g>a^UKCnvlwQ;yu1D@X3jmLvD2Gef6DYDDTQc9Hs0
zC{kbgMCwbONPTG&sh%=4H<9Ws!j<YNbESI9T&bQiSL#cHa`FDwovl}?f!CKjCDzl2
z^2{`PBPnW5=ZhrEbT`WkP>FrnRAOH~RZ8^2X7kH7WpaV8fwZd$pufPd%$aE_rNq91
zQDVL3kQ^n}^OO?%T9pdz%c>Il6OIoJkU~9jW=P3>(J23^2WORLxS2?avqa)c3zu0l
zI@N5|;mCavIrA}82bQSS8m#wzi#BwfR8sZUmlFGGO6AvAQ-d<koR!!Yi4tdt#8<>B
zw6D6A*jL0#?8{}wc?YtYao&-Z`x4`X_oc>>`;z0x_4J^bWvXz9)hL?fUfNmh%XFJ9
zt4LYzz_AYK9o%6@`7=FtDRG9|GS7t2cRQD2nU@E$+~X@x>q~*NdXc>Zu<%_kFDfRz
z<dK(5H*+bm-Xv3Ey-B9TdMepEvP~N+vej#b{>|uR9-k#g{xnKxJ&jDvz|6kZk?YZ<
z!)J@fpIH^ZzsW1PUhwJo^(GH_d3nYmL5Y2-RAOHumDra?CH5sziG3+lVm*PVjY_xj
zGBxpRGXr(YtXCm3E8~JcS0eW1N;Ml_BueayM2WLR;wu^z+E+A6>?;~2){6$&QPW}n
z;Gs$q<BhM#<l_!$^}fg)C7;~!m3qclFPZ0nO6)5g=?wKIB#1=iKriBySdSzn_N7Ec
zq8D*0w682xO7v_ZwDKLkNR(KQgrU_8&YvN*99>T?-7G_KrR927({eqplvl_kQ7^Hy
z+#in$pDi9ezv*~<4b!o!7eqSzpsXtnt~1THqM>;96%EDp^rHf@Oxjfk*K>u?&P3TS
zmyWMzDjnP>ce;YVb~85z6pssh%}vdJ^=gD=CDv;(CH5793hm3466>i)TGaGZH<=Ra
zCR1YFWJ;`?Oo@H1Mw!f#61_|iiJBYuOV^R>;ZZ6TWf}THTCQg)E!Xpumg|{H%YDh0
zl{<ejl~_+DbEQ6g^p(3K*Hf7euctCC*Hf96`^w&l-<Ntv?oX$)O6vm|T^$TNa$k5g
zSk)VqP@L)}MK6bxSTBZ@STBW?STBT>*q7JT+@b#D)R`&jpCBVoj)I;i#P3cmbp?Qm
zY@hLD`;aHwr#wpT%a{|tFK3x=PMOjS_k1a_uas42y_8W5ZtVVYkk~WaQlvh0s@E@4
zrhPeZe6rpi*q)Ws(36^$`_h`xx2MDV`$ZO~<iz94vUBf)d}W$VIV&x?7Ol%&0Xjh@
zC3W*vucV;l-v8}E$7e|C_;RVlzCu^xJ&e}whb&o#YYDK2;aYh14=_}DW&eP}{peEv
z*t(j}XQ<Du{ddi3;;OeJG&?2Mn^8)vx1yBT*Zou^dNCq&#)l))a-UHryw9rB&wOcj
z<o<ZFd>Y||_a)zv*S~M~6laDTcbOCUl9cJziRG5z)`<m?*$XMLKU)&oUpkJnspq^^
zBzm2&$EhX4Y`v=9c;r#gyA%?yJ`AfD5%ZdPZBi{O`%<sOdX>Pcnw<F~&vb*tL}r-c
zq{Mnbro?(uQet0HRNVf86qCMEQL`{#XlFg6UWQ=Q1$smPYV6e;SW4{6k_zq1Ql?>!
zMy1L4BFQq$DY36yl-TD|mDpbZVp7i~dw`mp)+-kRHE;6eKV$Pvhu2FWE%&8fYR{K=
zk^0h}p{7xYPD=DFrE17$P}Pvnq7wT|DzPtaHC*b`E0}ag(RwaG^(}wdDsNOz?ndJ)
zaf#g5Rz#|owi|;l>k`(NbCLQoE>b<;s6~<bQs#Whn>n<eHa8AEZLU;L1*Dm70#jnW
zEK*{hK^2M5qC2tjO<!b*Ji}Tm$~DssJH(mSPDQGx#to|{#+CZ2Mq<zl#SQB#Y}Hch
zH6|2FhP1g-Ujb%FF~X_=M$d>Fg`PM_os}1VI<nk`W_pwZc~oLOfhn<`l$6+4s45a)
zsVcFa@>C>xxk9W~2<zo1E%%4dxIpd9L%oiHaWJeeHzM_AMx?&Hh}4%Ak?JW!)reH@
zyslI)XjiJI%$4dXbESKjwBc#?`uSE>P_IxKmCVoT$yrd2LY7;B^zEE(3NbqOL%wV~
za$m+Bxi9OET+cjGmT^v;mh17S<$C;SdA9g{6`z_b*DG2_?k@-F+x1G8<s&Y=o*d~>
zAA#1BBfPpLgFNFcSL%sP|NJ#$mBY}UYc}<{pg$$5W9kL@f0cGGaB>vY{=h2_0)*EF
z5(xpZBcL(Jx_Ku&I~x)b43Iz!8iAcncJsi^?y}in2r8olL`00pML@(6#f#!2@CU&M
zI-&yN<3>aU5$=eu3n&IbQB=6qb$+L3&pB1e|Nr^V=R<b)+ow)fS67{xogKQ1DHM6x
z>vw~<MC3eZx;amXm+71F<~$+ZoF}+lqOn&NzWekB_^!t{`q%kz=;l!H5-#QDP!Mkp
z1#S)nZl)Z)ERZ8u9AV@Hl`NBcj{QbavOJ`c%`Pd4InXJQ=SF{uiDmARW$uy_xy=|-
zZh4et5;=mN={-n48IqsGFfT#TM5Zc6CXBl5eaW&vo@sK*#Zs~ynUZDh;-Df=I3>#@
zB`1>D;SIU%@CKHLQ|6Xq;yLj<FR{r@Y;qHu+<04Ao}Xf@sDR1?@}4NeblT*JC=MvT
z(qkvtM<@OWM{G_+;!kkIvfpKHGguUD28-AXR#=CLcj?OK_G!td9GYmmYM*$Qugsr#
zm#^GDYZv>Uy^HPgsQoEVJ;g>pi{ay=pT%gpTslpcr>yDb<j{*RGuMdCG$EEd_49#P
z?z3bwO(;6i6FFc$37u#4N}%a7-XAEvw2%i>vN@pe#)wK@M#}>#+4MaAK8o)nWj9^K
zXCh>o@Zp@tG{EN`WCPzH{GCko-)9QHcbR?$mC1c<;%|S%X26Ke3?P;RR^~P{fTB(R
zi2eUaDn6*j?*xb6(08)U^a+2LQlnE0Tdcq~T^@7O<qis`%4X&o+~%S9R315c&HQGZ
zlD}@_??dW{{dwRPI~iN`E_=}^y!94IMlL6k?=BskJPMx%?<UJ|?}_&qiD$%K{e<T~
zIod@x@d1g*%O$-0No_G*rBrj0`<7>-I76}e;rm2Gp@z=K$6ihpX=p;K_-3AHkMN<m
z$iamz(_=>wwnWD^Y?+yCGb_1ec5;h6<Hcdp0+(m7>2|$Pyj?Hk=JdsW3v8yBC(jQq
zg`46;oQO8ZgijdQ(u{YrV{bG@|F-Ho%72b9$(ofc^$U3PS<<IW{l7S|--5zW6>m;O
zPK15Ws*IMWq2$PCfy-A_k^haj+!p!Yh|6s|`=h=&k62VYYa`EQQA=ncCSLUw&p_cN
zyFBD(yTq%(vYnY!*q`i&AHpzs>}iPnZdHtT;tg}SO+)c^S;a1`P~<1KdB{_F<RCTk
z$U$hjuYS?lU5=hAkG>^+AVqm`I_UrMR2zz2MV>-RmIvt5gkYN_@vKiQlN5an=TZ*R
zkS>~2Pw{e)%D$Lrs)W9e(V_DThc2UG-<hMKlcl)W4Sp-rZ!iWn2NC-~P?^LmNQ$;c
z7IMoYD+VZxzMMoQo7@y_aub`}ssC#R9(}q^O@{Kl(V;`;&pZ8=BL}!-GfQH>Se4Oo
z5K6X3OAAuX*kaJIK@NmZRQ{zOmw+3348C3Xg+U$yt2_c$GebfK*?*2T=a8PO%<hQI
z{)o*EiOn8~6T376NzrDs!okRn_%Y-+B8HBg=g5(l!LrvJEW1$#%VQ}y@m%AVJiWX~
zzjH#{<yiQ%{NgNCNvN3_6l!Khh1eV@u{k7SIRJj1gwkmyMC8elW99x><?g&jKb6~b
zc`!{k*^wueUk-6Ik2y}{F=HD)ettC=50{<v=QSjeU1T*Kp<-r6oY)KtvD~3QN~)qJ
z39(5+oJb<OUFJ3eOG(V(5Swwr+p#8`UKB^lXLyG4&!I(?)PL3t|5v*?*r4WEgPKDP
zYK}ChInbb{<3aWB_RZ_)s9){<*$)k5r&(pES!JhLWv5x=-Lu0QI-y>f_#E_{ZNtN_
z+Op4nLIjn4W|e(rm3?M410C|3BMEBeQ>179I3hh`l|5sXJ!3U}pqEj0eBh>c^p3L}
zIG>zYj$Fy6gA{FgNG!YPli>BY*=O{sFU@$fSHzp$!sUMbsZ72f${Xb1_!g+8vZqa#
z!_#!x)27RwHr-4w?AIIt-1L*)I5OQNHoYV^ouv0FOf<3SI<e_FvFSLm={HRfzsPs`
z7~wDZKYMs?Vn+Du3oncM2saq@k?z{4@8<4~`Y2Z)kvshu;dXbEM#g*(mq&e1SBd&)
zw<+p-xwX5+^6%}oMtvWbkBY_b>$V&h^Zi^s>Md>=ZiwQBJVv-N?%JsD?^=30heXo1
zBisRQeALIfEb8Ojq^Q5j{k<=i-`{wJ@5wS`?<3rJw>IhrxoXrW3~Al`c7*e{2Z}sK
zIDZ46$YX?ibwvI3t)0KiQ{*wiy~e1&sfE8M#dELd4gMxce)ijO^Y>%%vwt7gug-hX
z^TKP&Tj34mCx-mZ@hSRIJp7$F{C@3u-0Z!`?{?4qcg@G8{@Y>B&WD@5$BygkA$~vS
zj?evf&K(~9b?#^W>oB*UYlHinnS{rm;S1q=!uRqWF5;Iee?5GK@_F!8$~)lwaGn_#
zz_%*@D14jpFTx*$k3v7c58tl*ckrJpALcKeUL4o2l)oDOB;4O>C_HAtcPL*9e_8oE
z;4LTQp*_#k_ru$ie;U3-`M2Qx${&MoRsJG;oALwvwc(57ZNN9tVYw;rN>2UE;HSZ>
z@Uigq@EZJB_?4U=-U9zJd<T3qd^_CD&4Zi;e->VWPlE3~lKQ_D&hvIMybdqcVexn~
zd<UHS-vb}no)=-oP13^SL-4FU4?kz&U+1oe=k0lrEd1--E$~Wv9wZC@I(HYm+MWlY
zfBpRi;dSK?!QDI=|7-6%Ti5lIDE@Fq4_?<h;5<IOuJ>3-@p@g4QO@gnf^uHhhbiZE
z-3Hg|dWmvg*Zs<QU0)8@>w2qlUf0(s=XHI9a$eUr!S%Y{rkvOHH<k0c-VWF6dWUje
z*DZ@^{5hW2b(?Zt*GrW1y6#ub>$(Ql>pDA`_M16+@Vd_7ye@cMSKxYG*Wh|xZ-b9U
zeqPsgxL()UoAVGk3GuwHm%w@6^180V^}5~$=l=7${w`dv>jpf-etBKH#d#2RUe}p&
zUe`ICS~b^oRXMNgy7CuywXT;@X0xv0JU->RehbC#>FB}F*JG5I>sooau9cVT8gACL
z@^W1(FV{8PtZU`vx>jDUYvtv-hVP4U;OFaY%FA`Fyj<6CUZ?zgy+e7qu9wsJb9}k3
zm6z*UdAY8Ym+KmC*7cdR-welFu50*Mc)70OW?jS0x`vx|4L9rht<)d0uHigy%XJNJ
zML+rZdK;YkU#@GoS=aCkdCGPDHtG+1xvrI$>l#k2hOBGl<+@h>vR~K5>npc{GVnYf
zyBql^<&)uiE6?HkD_;&Due=9-sPc>9hbzAxK3Vx~@HXZ5!)Gdg9Dc0w7vSy6_woZ$
zjL$;luZ5qgd=7k>@+I&U%Gbav%HIuNt^8_ukMdjL1Iq7(Z&Lm!{5{Hdz_%#h-QQla
z7>CQ19}3^9d<Og)<%{7rC|?D?N%>~@Ey_Ov|B~`s;CCpm!@s8d5qMqspW*i@AGHUK
z!w;3e8vc;-8SqDxp8|hEc{lvG%HIutTKRv#cPRe?{BO#?1OJ!u$Kb=?F6+Sa@I938
z<)65V`LM6@!{B3;9|NDD{0w-e{2lPuDZd#0M&%!e=kQ669=E}(%I}BQl|K%5XVExt
zp65Bg@;&_%O)(Bt<r%!Ld=}iDE%ToW&y{y^e&w4vzw(c8{&QshTR6Y+Z*hL*Kj-|)
z|HSz_Wd4zR(KzJFC%~)9r@-sV7s6dd=I`MA%FpNg%0I;Um4Alwcgp-<=lsea;{3{=
z;{3{sU(Ad7;8x1~2f}mZt?;Vy`S7~(vpN4NnSUeaSAGTOSN>_vul#GAzf0zSi1RCd
zn)53k?%xV5#-Xl!0^D`W{8Qn%@<s5f@(SlyzKQd%mif1Ge&x4te&uz}uly0tzeeWY
z!TFW%;a}K?`k*|6*OkwPyS0@64o8nuIbL}e=U*q|H^cLDrElf@?~wjk&aeC)&fg>B
zABN}ar9T6Az0!yIB@yO>@&n=3J{jK%&-<m%hr9EnpT+r=Z{Yj`GX8STzd`z^IRBvZ
zyEwn{A9MbVGX8g*|9t8H;{5NFet`c)CXA2r$?)nX89x`EUm*RhaJN}{ALmzoDd)dX
z#(#qIzf1ZZod4a@f57>bKgs#uBjaD<{1-{ze+-R-t4e<ZyskWlSKlk+&xGgilitVq
zFP8p(&aeEFoPUdqzl-x<BK^NO|E1D@&-s=AoAbY4#*f>d#v#8<`cZKA0qOJMb>(Nn
ztC!38jhz33(m%xcuaJH-=U09Y=l_t5{~71MlDy*R@eI7CeAodv?;n=&2f{1LkAl~g
z&x2=MWu6uAs`B&T4ds`?^N+|pH^OVm?|{3jWc&}{73ELD>&pKD&ps;iwD>m`!t;po
z*TWmikB8@1%RI~AHRbPsyZ?~!?}JyAUk9%%-v-aFk$LWiSCu~jZz%sOJpY)?v-da}
zhnn)k;O<%(e>A+Jd?~!Hd@Ve?PUg7?URC}vctiP@;raD4&wcQk^2g!s<1+pQct!c%
zucC3ND?c2b-5~QE3$H3)25%_uf#;u)c`k<6lwS{bH_G_i;T7c%!t2VPglC_Wd0v87
zmG6HbjYC8EWO!badD`JM<tyOsQ!;)4UV$%g^tcROSAHWryNU8}{2lPB@(1A!<qdfL
zX_@Cmcuo1f<7ph+XJq^l@QU(d;C1Co;n~eH&sum@`9<)C@@wGvXJwu*!fVRE3wQr1
z;~#@pls^ZrE8pWF8i(u_nddd|s`8oehVoP3`R8PwE_hA(g>d(I8GjYLqWp94y7D?a
zyH)1-1-z>KS$ISFZWCx6@-N6dhrnyfr^DSBW&C1zMfoatUHN8s_9dC;Bk-#7&%qnY
zzYWj7Eb}}HuPJ{H?zYMJJrAaFs3_0ib>*|**=;h<Y4ED@HSmV=i{Sa~GSA20HRWH1
zyZ<BO?}t~E|2Mp@{6%<nhs?9zAv6wEc;@JF1iYsF7<gUzQg}o88o0ZY_RIO-4bPNc
z4bPR|3a==?7hYBV2)w5JS$JLfZm*_sXed7f?!F@XKMkHKKN+4Y?}S&BZ-Q5qUkR@%
zzZqUv{tb9T`A^~QF4_O5;hFMbhoU|x9}ll6e-pf_d;z?s{A_q#`5?TZ{DW|Jx9tB-
z@J#tv;kojkz$?n1f>)InAGs@DSJ#vu2(K$|g*TKhfV;2C{+|QSl%EgJm0t<3DE}<H
zs{9^!P5Hy{y7E858_Gv!G!E`-vj2y`Gv(9ax$?#Eit;XaRr$N%HRV^s>&m|XZ@>?C
z^tczEeLWAr{s_FH{8@NS`N)Z=56UONvv0`!Q{WZl3*j~89h_hJM$Uha%>O~ouly#?
zul%c=U-@><|4o_y51e25%bZ{NxYuHQlphJtz9sXw!z;?)2Cpga=lsgw&-v>z|Bdj9
z@;l)*<v)Zsl>Y{veOu;#30_e?<}lO^<&)qI<tM<idu9IR@QU(Ycuo1G@P_hFaQ^Se
z{C9AE<v-y3%74T8mH(6Te^=%|z%R6-epZwp39l)i2X81}0nffC^Pk80m4ATqEB_Sd
zSN>Jbf1k|%6L>}WQ}CMdVMk#8D?bRH-7oV`fmf6-f^UV7b@Zsfw<&)oe7o{1;X9Py
z3~zaW`osCZ0dG_OFno#fKf?Q!k9-}C!&c=7!?!7)3g52$WcUu{E8#8Qm;K)iZ&Q91
ze2MbU!~2!r3*V~zQTR6H&%w7V-}Ch}4m*@jgtt5>`#%TXrhF-UiSl*ue&z3lZ&iLB
ze4Fyy;M<jdAHGBRui-5}kp2G$yiNI-Ni+^iluw5DE1w77s{HNnZOS*mw=4f3e24PS
zz*~MO`+pC-P5IB^OO*c^-miR*H(>rN&*0mX&xUVTz7)Pg`ML0xAIbh-3~y6@1AK|{
zJK_Dxe+=KM{15PL%H3o--tEc{g1aA6Kd*K4XoJ_3p9IhUOU9oAZz$gguWpy|SHQEM
zNdFAHuKXMD%0n{#VYvIL^k?8T<-?DpamXK*@e|+;<x}C+pUL=>;n~lnuY}i?Z-!TX
zA>*%tyGNvd4qj9KZFv5ujDHl~Q2rde`b!zV=NoApvd5%Pgx8hNfmePd<CntS<I>l`
zYs%jX&!3R-*TEagZ-ZC=TgHDMo;9TZ8eUia61?(j8Gpc0G!E`b=|{qA%ICrJ-^lp4
z!yC#6;nm;D_z%Ie-%0;0ysrFP@XGIH{3CGp2kATDHRXG>V*dY+jGqW^C_frreM-ik
z0neV6-UF{IzXV=+M#kR=cYl<A7rdr?J3RlBjDHH=fcuw!;qeMQdzRwa$GwThp`!dq
zcuo0SctiP_@a)er|9Z}^{9?|p{5sCBd>iNAA@kqQ`ISGx`IY~b^DE!G4Rzo-ng1|&
zMfuV2n)0RahVr$X|1UECMevI9Yv48IUxYW5e;1xTFY`YJuPFZuyrz85DKriZ<rzGC
zLFS(YuP8qiUQ^x;Zzz8k=l`qB|547b{PUb&`L{X0@<%xT-(>zjbAIKcrqVdnlphLj
zD4z+>UX=Myg;$iX=KRXv!}*n8!}<R%^M8r+E5DEPD}RFXEB_nk|A)-K?=;j0<*$R+
zlphaoC|?fGUXuBHIluBtIX}GS=y3x)|0m^Pza8FC{s6rCFB$&?Jo~rw7vOc}qo-pW
zUY7A0+`S@wCcLKn6nO6Dy5dm_|2o$NZz#VIUL7XmuYza8rGE}yS6+u#M#%VIz}-mc
z&%$fUcbh@uknbkr4}mw7PlH!S$@r7u+3wOi;dSMk;FUdO{D<LgPwAh9*OcD_&qvGn
zhv5z7&%mpD$@t+jX&kb>r5^;ZD{q5W_L1=?!QH;n&w<yJZ-nRj$@nYa4dtJPS6gKK
z*WuY1=|6?nl|KWo>@VX-%%X8{2S`5{UQ<2|o{yFBZ-zINuYy;{$@mN5*{h^~6kb<;
zE4*@`jQ<YYjhFryyr%qlcz%$K-)lCFLqqvt@ahDLUxD>LhvSu>2G0+c@!jy6@(bba
z5E=gwct!bt!t2WKfoHFld43A7Dt{W@P(Ex9>cgQj&v<xE`J3SGH8OqyyrTSUcwPA*
zJj-OB55lX;Z-O_Je-)ljlzFzpYs&uscdwQ4FT*R!#~n@MQ&;{*cy^e~GY?)>z5?D*
zejYqOT;{n9UQ_-_xI03|e+6Dq{v&u@`ETLb>tvpP!mG;nKL+bX`5WN*>t&uCUQ_;7
zxSJ&7`{5Pkm%;1GYw+w1GSA)cs`BmdhVuV`=aXd~cPt%mP5F4ZJ5t8C!7Iua!t2T_
z@a&B;&n9?P`Br#C`7QALD4C}Yufh5E$DeZ^<$r`{t(1r3haX4dP*FY}UQ^x*Zzw+z
zp1n!tU%~m6_j7*b@8|r=Z{+-KGXI^NU-=I?zw+O3e&sK5{wXs5nBy@%$|u2V%1?kd
zlrM*8Q)T}3oL~7C&aeFAoL~9voPV0k|9#G{yutaEzsUKO?|TA`LpELJKLTD+ek{DE
z{0w+Q`MI2bhRpw7&aeDh&aeE-oL~8UoPVaw|2XGY{#VYge4m`gp`rW;cs5JsKMr0|
z{uX#m`FhT;{1VPTTju`+=U09w=U4tC&ab?9Td(+gYc@yb|2OAXKF)`Q&$lQq%1+@8
z<@4d$(K7$p@CrP0^w<EeD*phyru>uey7D{W4dp+8yJP$}{*i@$o%=OBQ~n}6SH4d>
z9dAYX;qa>RW8gLAr^D;Y*TEagt8jO$?ElB$nes2ebLHQISCsz>URC})yrz8gJQ|0(
z@`><<^4V~Aob3N;@J#t?c&_~2@QU)Q;Z^0g!fVR!h1Zoo3U4Ui0e8pC{_lPwjYFpV
zP<XC<2E3wtF}$jL6}+Z=GrX?+DtJTr=i%-I+5datnet!4bLD@5SCo&QPvcNk{#tlV
z`O)yY^3&lB<>$g(F8lvJc&7Y%c&_|*ct!bx@T&4B;Wgzi!Rv7U=iTravw+6I&82>_
zPlD&lPk>jIFNfEaujl;jGXECNul(bjU-|8vU-^Taf1b?$B<END66aUG|4FD1$|u9!
zi86mXJXgK~UR6H8`ITSJ`HLqY|KRbziSsM}8s}I35a(C^H0NI+^ABH0$D1pk0Iw>a
z3a=|a8SYM!`B!p&<(oOb@~b$%^3QYrg);xWoL~7bIluD1aDL^Z7h(P{lKEc?&y^ny
zuPQ$SURU13`A?SlFX8;kZ{+;S@8bN*w{!kC%luDqe&xeYrsJ(DKNwzDJ{|5B%lxOn
zbLFc!zw(PXzw&E2|0y#6ZJb~EgYdQRy~C<;?rHd-^3iX`@hYDTufdlf&&lu|@UigK
z@a$CT=h|Vk;Zn|X8u<#u-voC{$m{TX;dQwGvs!pO!SPEe{tEcZoF9G|e8OTnt_FM=
z{AhT7I^`J$Uk<OpbNKo28oUL56}+zEZ-=`xC_l&l7@ooXatn`V;r;Oa;iFHX{?}Ce
zWcUshzW|;sqy0`oo;C1=@X_!s@QRAR8Gf0HzZYJEw+*92zkxU2Li_cHLyuFb|M_xq
zj-Lpxo+;yxhd1CH-vQ6wCgb15dEh*rH^8^Uc|7liyA_ltA4c7L1fIX0oagxq@EW{|
z!y0=U9anZ1#b@v~cn;_Dz68DmJ`(Xg@Cy76_!XT0Y|4KW{1%RfUjcsr?#`ijp8vmv
z=WrgMk^TUS-|x1<d3-W>UB&0{mJZ6#@n^wvcpLijE_gqDZ}_$FDm;hZ4X?vn;19za
zD*gp{R-yiIe9KbIH#p~SgI87jVt5Vi(}u@-_zpPNx69#KC+(NxZ-w{6IsO68ui~HL
z{3?Fb>6lk5DgSizXCk};p8!7&URCjLh1XU5AiSaCKMc=S(SAAqt?(Rv2=;p){4Dss
z@F(H@D*oT_D^&bJXVCH1RQz=KH&px*_=E5f*zdXU?QkCdEpXRG$HmV(H^M9MHsrY*
zUW4;GdWiGGdA|J--hl6qJfoJ;as36(^>!lMbyI)1P96(i0_Qx-;Z-=#w|;m7&h_DP
zc*|<a&v`xrZ-aCHzX{LbW6}R%{%h<yy^n_YG46pilpo>l55dPquhSmO^SqCD{<`1#
zdha9OQjD9uuKPaTi+FwA_$;`+{`|C%=RkA4_eI|K_tzn>7H{bJ$MEp4b8icdABKGS
zn)fVnefXY4{Cm8&`1qdw&LLTxyCe~RMsRz*{reK}*CqUJ@5O%gb?m>Fi2tScO!Sa`
zc*^^j;rqD<Fg_gex5EAN1z-Q4pTBlnPUG2v_--_K#h>36caXb9jl(xXf9!n+#`!!&
zydJlS$iL;7JY>Ff813M7-pBa(8uIUf{Z0$<_+iMG1qpw9!uyK+!^gXR)&C1a{622W
zAvtA#4Sl%*e$?*dXO1J^FL>m>466nPHw<oEy}EUk>*zRn-sv5S7oD-Jqr-J|4|K0t
zw_&h*pkr`-$Eu#b-tG-PqN}fCO;6v-&Yq60!M=eF9i1CDxmA7Z`+K?vySrLvPMa|!
z9@MdVUGKV%&Vhl>3p%=c2L~>2s|PyQcXxDcT)+MT-(<*79X@hUgs$pcGSIiGV@-E&
zNBc=rJ37zbG}U*vXX9W;c{i_ly(bOyZS3FR1EwUmObuIlH?D8*UDP|Yg}?LVG~PDv
z|7n}Q`B2dhpVPLR?eAGc+vazz>E5uUd!W5IfN;Oh)RtyG-KLpM^*-D|lJluv>}p%8
z_r6`CCnBThW3i>or?)h-6}@jCa<+!HvfFmnPL9ZsoT85^r|6~KhW(ZEYDm`Rc}r~F
zd0X_>v|ZdYASOjRAeFz&klIC9HU8$VVUn2q*h;4^v32LWZjQHUPJL?*dOE=GqNp)b
z{awwv``68Oo4W`4nm?`Y+_ZS{>E*^Ea)!T^Rx`5vi6YA%MeUfvwIhB*$jI$e{Y{P{
zx25$O?v!iqSXA6e*l7GllXTmA6HGT;v>e}IxObZgj@+`#cbV@0ZGvMrOD>{Qx95u<
z;?(#qW48(Qx#Own)@Y`GQ^Ot5Eyt5gi+6->!Dy1qh@bM<Er*LCiRY$UlbPI!yA9G^
z`%HA=7FcxSDH9#N1zFL<#9+}~zfGFy@iCkoA938y*<^{{_`K*0-IvwGC+|<07%{qy
zt4TvQ-!dG%U$pN{@?L0(A)c0)8&hI8NG^_cPJAv+OPrFTmc@z%Zj)|~D`Yo!Hw(qd
zXs8uN!yO5YMsE9B9L<!Xb0#=;H`pRNzQa(QOpb8aMyWVij_07_WTNTLwwB|&q~c_v
z!<sNk#mO+8T+8t!RGdsS6(_?q0S!}eGEBwEFcl}miF=;XoHWsi8}ZS~G11ZcAQrPE
zF<4ZbOd2XqhN(CiMsc#97~JS>-+d=hoJ=0vRn<5ZC&N^n3`cKTU+gt;nx-a(7{$rv
zkKLxd7<wvBCLYDfIEs^T6er`MIGH;#hT>#2)C!}aI2jGa$tV>k%klkDaWc`Nuow-M
z!YCCd%kdmkoJ=$oC(H3&#%`JJPh_YoCI=NK!?fNk$CFTTGSRet3{!D3OvTAC6(_?q
z>kaSp&dVlxr?&$&(I`&V6N5#?$%IpJGEBwEFp87)#NeVhnRpZ@>xmJg;$*_9I2lH9
zGLGV8or;rj6er_&<z$_TlW`O$<0wwXQJjp2;$&_B8;XU|P@Ig0;$$=wC!<uHEXVgp
z#mPj6!eTU33Zqn<EXQ+DaWc_VoGiz8NyW)Thq_{vij!elZ<gaps5qHuT0e%VI2oqm
zWSEMRVJc3BX{i~eS5AhhI2opuV;IHBdSbAsIGJ!NPKK#C8Afrko)}ydClin2WIZur
zRGdsW6(_?ePR3E3tS5#T#mU5@I9aFSWE{oGIEs^T6er`MIGNi}hhkwg6epvhI2jGa
z$tV>k%klkDaWc`Nuow-M!YCCd%kdmkoJ=$oC(H3&QgJfTp{^LE;$)cCo8@>CDo!Sv
z){kK-PKK#C8K&Z7n2M8OT55)=I2oqmWSCZtVH79piNT`cWWuR98K&Z77{$qYVsKHM
zOgxH{^~8u#aWdgloD8El8Aoxlo)}^jClin2WSxqWaTF)xC{D&voQ#L!G~2COH?ZoA
zwd+<7hCfu$8{$SoaWWc;lhII|j8bv39Ey|W_zpv1F~Oly7^UK5Ii7=xlZmF{WI4V|
zDo!Rk)D@#toD9=?vm8%C#mPj|`Y}w!$uJcs!&ICMQ*km(OU*D9C&N^n4AaUnjN)WH
zF<4ZbOgI%M!&ICMqc~Yl3@(b3iAQm=o)|GIP9~g+lVKDm<0wwn6GM#RWa3ertW$9^
zj^bn-#mP8|lkrfT=0uB=(NHUlhT>#26epupoGgdpWI4XWP*_ZGs1!!2I9ZP8pyFhr
zsW@4V?~;m>i4JweC>1BewB9VolTdLo(X@UHQ*km(#mO)gC&N^n4AW9GOvTAC6(_^A
zatxz5Sx*cW6(<u;#mO)gC&MUC))Rw^;$-4coUA8CjEa*9r{ZK7#mP8|ll8<9qd1v(
z6esIcoQ$J58Aow4j^boI6sIX|(duM5R13?YK3NV0$}&}`h=&pt@x)$3fwAGCWLTy$
z74bwGDpWR}DpkZ2`=wfC<3pXXOx4Odt-y#U@=(FD@wBL{Q^~SUHOo2`E$dXZtkWX2
zPIb#V6)x+vtgNGSMK+{Hj*6FUK-J4Sl`re4Uy%)|u|@^6El|QD8&bnZMa(v!DrOyJ
z%x*v(i)=`ZI4YTKfl?OPK()+nKryo$P|fTHlry`5>X|8XR9XyEWid?k%rMn6!>DK0
z6Fa4MtEQNEDny2<t{6r=vz|zUdS>EL&#Wi*i+X0_sSX)NJu{9~X+4n#^~}U$jTuKh
zGmd&@9QDjN>X~sYNaLty#!=6VV|5wldS*AIMh^ANG(bHwj(TRC>zUn<8f&g+rUlnC
zyCF4vsAr}D>X~t_XJ!M}GrJ)*;#|*63$AB&1L~RC!1c^*;Cf~@a6OY7ruq+D*w0>h
z4V6WH^2%#i`9?#HGa6R6(NOq|h9zk<R70awmMn*lX<3dRUhJc#{`g`a04+FvgtVgV
zF5^c-tI9-Eb+jBG>ez=%eFtM7#Pdv*)a0ghY&m|$Xd#(sTB?@g2T#S)L{lv@OeNHE
zd`zhDnP{p$mg60y<!_=<B(2l4j`hS@#tOIbiD5+5vGK7Fk`^<R3WbSBeY8%`I@S|s
z8)e1DQ>`<O`eZ#Z5m22>d|18mGgigCwx7uK8fJ%y4NKQ(nCeDDaWWbvjL}e>j8bv3
z9Qh1san|C87yD>w5gk83Do%En@k68+X(pPct>t(JY4X_U_%34~#4Ao>_-M6BLdD5)
zJU2~O6HTkia{N@%oHWr?oD5TOvK&7<RGdsS6(`H_4pMP4(I`&VQ}ZfumQkE+p2RSs
zIN5kAPS&Y78Aoxlo|<2YvyI|p^H6azj^boJF%eLlOng`z@-tS&ye^89(J(uVhT>#2
zOm(B7I2jES#%L%`MyWVi4#mlG{P3ta+35HIQgO1;@k6BIWTI)>T8?*+CXbDd?~;m>
ziKgOYIlfE!)zL)LbhR8GD*7$TMAMwK96uZ?P9~au=`l>j$uJcs%Za%b?+J>N$%0@0
ztS8Pgij$3};$%HB1o#!w##3=Jj^boJHNO&P8^y`yq2gp5#mRbNBA_^#_%KuDXRNq5
z84VNCXedrb!`U_(ij&bWVT^|2WR!}N<xrd~#}AK+lZ}oaAQdMY9X~`WP9~bBt>t(J
zY4X_U_%5k9nP@6bmgBpm;$)&}x>}A86%{8FO>@$6{BUSxnrJFchN(Cirs8BdG1uZf
zL2)u!P@JqM&N7OVji=&dJuw6*PBxy3lW`O$>#6ybINK;rHV+ji<0wwn6B7Z&$;5}5
zDnG`+#mQ)xkVZpsG8)dd(NLU>h6!Ud6epupoGgdpWI29#RGe&d`~ayq+35HoQgJfT
zG;J-%J4lnqM#pza#mPidak3oWB^4(VP1DtKe5j~6nP{4mmg9#*E7L?%aWYKB$uJcs
z%Za%b?+J>N$%5i!J#m&%oNPQ5C+mqJKykA1RGf^XI9X54uf*9#ak6=+I2lKAvYwa-
zC{89m%vAMvKdw%e!<4if>XYSg#w~{mWjRb6%b`YDrXm&bP^BWCI8drnk@&=+Ql*N-
zCk~csm5rxq9PvayX*xyX6Z@rtW#g%0MLe-z{Gm{OqQy@Tn#MK{Ew_j#PA^SY8z223
zgWoSLTN{tRbeVoq?XvMyyds|HXY>;QzCWm6HWB~b&-4iYJ9MN)>YU+13y~J7(cnKJ
z+MQDwv#C(WA{&x3FEs^F$|9+#me~y`W|0l4>49?QTMW6fOmVfS_KmCgvO4sqzSQ=q
z_@iHH`|MD7rtKpCbhom1N#BO{aHT4>@9Dc}J7XtpXY8Ww%$>BIxr?^5cG7lMvMr5Q
zye)4_jU~SrOpn#<UF>&uw9mBPbX(f*oM>C#mg+O*j<@A)skY^lO8S6zGIJ@r4~Vrc
zH|}EJ@s6Wob9OP>{=+mo*>}1%t(ipYa$~gT;aXC(V$H6HY}<L;$Z9OxCRSs(L>2vo
zExKR)^)0nuIvw%-^0ri4e!DojU%XkKY>PMEqiwM**%t40McZOqvTev6sXpa6CaRC$
zPU8`8%iEIs4gHE#f%5z&szBMVMB8vY>9*9bcw64K^FGJcaoOoq6)1b1Y8|@0lh)L?
zMC)>6PtU+q{~w+==XP}sxg?#~)LuNv@$;%nH7l+bmuhCVHTPCrzAn|wY(uj!f{A9a
zZ9|%+IvK`XrEE4c{pTU^&HT3h;x#~Vamk^tLBeI8Qd_1c+ssIAnVH-&E4gKMa?70L
z7C&!N-S)*jvMK!X5FLfEC3>u3OY~U7mgupDEzu(iTYSGeIu@Kh_mue^^G`j|U(J**
zZOY$^3ygNTjuYQ@>fBQn&GS)1wuIH}>7-NN(lLJ_vMoIEbk}jx;?vsaF77yO!Gbg9
zFY8z~w|(*aVh=s*R<7z;wP9np)T!%S**7ql=O-;*)IP6cYU|Wie}o$cH%RH|?&=)u
zbgTX4RX232O_VS6qNBK6q264yr0bu$)%^qOdIwkQh&Ai`dMP4|K-Y%8j<ub=T|M2d
zW6^1TL)W_Aj*T0-{QxxkUJQW$dF6%;$X)E(t?KtjHPC%t$4Lt}yVZUD-KsYmVjWoh
z&VhA<=BSpPG7smZcVO{}OXhXp0*%FWQT+v8y9YY`b!9u|E`RG(rvs+y0N1+Vg7t%)
zEB)8O0s6X@zw-mqJ<#u3d;12vTj#bfI%=?U4SrhFyRmiU#&tbiN3H8}t;J7kJ2$L#
ztz8%N`h4_taDcX)-#xHlU0<*Gp~G(*=<ew(8sNMBo<Y|d#;$d+dz1gZxZJJZ))&ri
zYxi1Q;C5}7Z_7VX3%b%Rwczj1UFE}k_RjU|R{34``Go$T*02}K=uePq^%ve<?=Pn7
zL%UaQT;m&e_WJA0@{j9!SNHMvohw%kbf3>Z^{ngd=I{M@(G`OK|NcGLH!m)U%-6A=
zJv{e6IX4@?*J}^x|H0*x`A1h=-+XufAGcpNJoi62w+xVlpPK*hb)Q+L_-}@`9~_>C
zO@nBEc=)OLk8XdW-}JXvUg_igUpqVx!Pf$~|GNcsj<55KADzEFgWJph$L;SPp8KDi
zyBn|v4tSKe;#+P%z6kOUe|ctCTtlAQ*GJ_3C+F(8u>6|vQ}Z7^e&_g2uMFw`q>*_D
zo`eH^6`FGYc|ZL19e(@EL)zzPpQC+-_PYOIx7mMFgmS(L+E>t?kCXSWkADl=w<F;u
zwBLmGJK#loe>HV8eph-c#-!+9@mRZCj<4a1<NFBEPt;fbzWDk9|KHH|ThV?iI=pRY
zu>YQ~ThCvwR_*gqd1#TNL+!J|kL5qyj^TR$&CvaC!F9~H`1^<!k3H#2`7eg0{JG}8
zE86q;^Yzi|Xn*yjVr%n}H@^+v-Qxcp+I|_X!@q1bwL4M8>-~R4wZ9hauSNUma`)x=
z<Fs}EO>yrAO!xBo`YpZGkmn1>^UwVChknC;L)!E8{Kx-awtvL8E%wCw&w4xkPtM;*
zVCVY}LH?h|{eQ)&=Ju1&eiGVmr!?jK<bLx!_`PpCbpL<vqy7KAZ|D2xJkO~1j;|Nr
zPwm(G?L!~jj=#R(HxAuDU%!7X+UxU8S(_PO^4}J@`1q^Xe-GMEYKDgIGWGK-{^ufR
zn{sZ?_m$wyynp^$)K~tVV~VfWVgFl)qW@mU9++tVhVv+L@dYx0Zhu&!{l=#$@=0Ep
zNTb_NNwh!nPZW7IpQuFp<IrA@-!p%u_P;$d-hbLk<Dt438f-s>^zN0^exm;}+)oDX
q4%hXfKJmGyNc#7(ZPfmr;t6iZgZIlc#(xuQKYw@9g{p!2(fuy~nS7rB

diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_bnProc/Makefile b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_bnProc/Makefile
new file mode 100644
index 0000000000..5c91b2722d
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_bnProc/Makefile
@@ -0,0 +1,27 @@
+C=gcc
+CFLAGS=-W -Wall -mavx2
+LDFLAGS=
+EXEC=bnProc_gen_avx2
+SRC= $(wildcard *.c)
+OBJ= $(SRC:.c=.o)
+
+all: $(EXEC)
+
+bnProc_gen_avx2: $(OBJ)
+	@$(CC) -o $@ $^ $(LDFLAGS) -O2 
+
+
+
+%.o: %.c
+	@$(CC) -o $@ -c $< $(CFLAGS) -I ${OPENAIR_HOME}/openair1 -g -std=c99  
+
+.PHONY: clean mrproper
+
+clean:
+	@rm -rf *.o
+
+mrproper: clean
+	@rm -rf $(EXEC)
+
+zip: 
+	@tar -zcvf sauvegarde.tar.gz main.c bnProcPc_gen_BG1_avx2.c bnProcPc_gen_BG2_avx2.c  bnProc_gen_BG1_avx2.c  bnProc_gen_BG2_avx2.c  Makefile
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_bnProc/bnProcPc_gen_BG1_avx2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_bnProc/bnProcPc_gen_BG1_avx2.c
new file mode 100644
index 0000000000..5fe08998d8
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_bnProc/bnProcPc_gen_BG1_avx2.c
@@ -0,0 +1,1777 @@
+
+
+#include <stdint.h>
+#include <immintrin.h>
+#include "../../nrLDPCdecoder_defs.h"
+#include "../../nrLDPC_types.h"
+#include "../../nrLDPC_bnProc.h"
+#include "../../nrLDPC_cnProc.h"
+#include "../../nrLDPC_init.h"
+
+void nrLDPC_bnProcPc_BG1_generator_AVX2(uint16_t Z,int R)
+{
+  const char *ratestr[3]={"13","23","89"};
+
+  if (R<0 || R>2) {printf("Illegal R %d\n",R); abort();}
+
+
+ // system("mkdir -p ../ldpc_gen_files");
+
+  char fname[50];
+  sprintf(fname,"../ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z%d_R%s_AVX2.c",Z,ratestr[R]);
+  FILE *fd=fopen(fname,"w");
+  if (fd == NULL) {printf("Cannot create \n");abort();}
+
+  fprintf(fd,"#include <stdint.h>\n");
+  fprintf(fd,"#include <immintrin.h>\n");
+    
+  fprintf(fd,"void nrLDPC_bnProcPc_BG1_Z%d_R%s_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes,  int8_t* llrRes ,  int8_t* llrProcBuf ) {\n",Z, ratestr[R]);
+    const uint8_t*  lut_numBnInBnGroups;
+    const uint32_t* lut_startAddrBnGroups;
+    const uint16_t* lut_startAddrBnGroupsLlr;
+    if (R==0) {
+
+
+      lut_numBnInBnGroups =  lut_numBnInBnGroups_BG1_R13;
+      lut_startAddrBnGroups = lut_startAddrBnGroups_BG1_R13;
+      lut_startAddrBnGroupsLlr = lut_startAddrBnGroupsLlr_BG1_R13;
+
+    }
+    else if (R==1){
+
+      lut_numBnInBnGroups =  lut_numBnInBnGroups_BG1_R23;
+      lut_startAddrBnGroups = lut_startAddrBnGroups_BG1_R23;
+      lut_startAddrBnGroupsLlr = lut_startAddrBnGroupsLlr_BG1_R23;
+    }
+    else if (R==2) {
+
+      lut_numBnInBnGroups = lut_numBnInBnGroups_BG1_R89;
+      lut_startAddrBnGroups = lut_startAddrBnGroups_BG1_R89;
+      lut_startAddrBnGroupsLlr = lut_startAddrBnGroupsLlr_BG1_R89;
+    }
+  else { printf("aborting, illegal R %d\n",R); fclose(fd);abort();}
+/*
+   const uint8_t*  lut_numBnInBnGroups;
+    const uint32_t* lut_startAddrBnGroups;
+    const uint16_t* lut_startAddrBnGroupsLlr;
+*/
+        // Number of BNs in Groups
+    uint32_t M;
+    //uint32_t M32rem;
+   // uint32_t i,j;
+    uint32_t k;
+    // Offset to each bit within a group in terms of 32 Byte
+    uint32_t cnOffsetInGroup;
+    uint8_t idxBnGroup = 0;
+
+    fprintf(fd,"   __m256i ymm0, ymm1, ymmRes0, ymmRes1;  \n");
+
+    
+    fprintf(fd,"        __m128i* p_bnProcBuf; \n");
+    fprintf(fd,"        __m256i* p_bnProcBufRes; \n");
+    fprintf(fd,"        __m128i* p_llrProcBuf;\n");
+    fprintf(fd,"        __m256i* p_llrProcBuf256; \n");
+    fprintf(fd,"        __m256i* p_llrRes; \n");
+
+
+
+   
+
+
+    // =====================================================================
+    // Process group with 1 CN
+    // Already done in bnProcBufPc
+
+    // =====================================================================
+   
+fprintf(fd,  "// Process group with 1 CNs \n");
+
+   // if (lut_numBnInBnGroups[1] > 0)
+  //  {
+        // If elements in group move to next address
+//        idxBnGroup++;
+
+        // Number of groups of 32 BNs for parallel processing
+        M = (lut_numBnInBnGroups[0]*Z + 31)>>5;
+
+    fprintf(fd,"    p_bnProcBuf     = (__m128i*) &bnProcBuf    [%d];\n",lut_startAddrBnGroups[idxBnGroup]);
+    fprintf(fd,"    p_bnProcBufRes  = (__m256i*) &bnProcBufRes [%d];\n",lut_startAddrBnGroups[idxBnGroup]);
+    fprintf(fd,"    p_llrProcBuf    = (__m128i*) &llrProcBuf   [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+    fprintf(fd,"    p_llrProcBuf256 = (__m256i*) &llrProcBuf   [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+    fprintf(fd,"    p_llrRes        = (__m256i*) &llrRes       [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+
+
+        fprintf(fd,"            for (int i=0,j=0;i<%d;i++,j+=2) {\n",M);
+
+           //for (i=0,j=0;i<M;i++,j+=2) {
+
+            // Store results in bnProcBufRes of first CN for further processing for next iteration
+            // In case parity check fails
+
+
+        fprintf(fd,"             p_bnProcBufRes[i] = p_llrProcBuf256[i];\n");
+
+            // First 16 LLRs of first CN
+        fprintf(fd,"            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);\n");
+        fprintf(fd,"            ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);\n");
+        fprintf(fd,"            ymmRes0 = _mm256_adds_epi16(ymm0, ymm1);\n");
+
+            // Second 16 LLRs of first CN
+        fprintf(fd,"            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j+1]);\n");
+        fprintf(fd,"           ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j+1]);\n");
+        fprintf(fd,"            ymmRes1 = _mm256_adds_epi16(ymm0, ymm1);\n");
+
+            // Pack results back to epi8
+        fprintf(fd,"            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);\n");
+            // ymm0     = [ymmRes1[255:128] ymmRes0[255:128] ymmRes1[127:0] ymmRes0[127:0]]
+            // p_llrRes = [ymmRes1[255:128] ymmRes1[127:0] ymmRes0[255:128] ymmRes0[127:0]]
+        fprintf(fd,"            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);\n");
+        fprintf(fd,"             p_llrRes++;\n");
+
+ //}
+  fprintf(fd,"}\n");
+
+      // =====================================================================
+    // Process group with 2 CNs
+
+
+fprintf(fd,  "// Process group with 2 CNs \n");
+
+ // Process group with 2 CNs
+
+    if (lut_numBnInBnGroups[1] > 0)
+    {
+        // If elements in group move to next address
+        idxBnGroup++;
+
+        // Number of groups of 32 BNs for parallel processing
+        M = (lut_numBnInBnGroups[1]*Z + 31)>>5;
+
+        // Set the offset to each CN within a group in terms of 16 Byte
+        cnOffsetInGroup = (lut_numBnInBnGroups[1]*NR_LDPC_ZMAX)>>4;
+
+        // Set pointers to start of group 2
+        fprintf(fd,"    p_bnProcBuf     = (__m128i*) &bnProcBuf    [%d];\n",lut_startAddrBnGroups[idxBnGroup]);
+        fprintf(fd,"    p_llrProcBuf    = (__m128i*) &llrProcBuf   [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+        fprintf(fd,"    p_llrRes        = (__m256i*) &llrRes       [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+
+        // Loop over BNs
+        fprintf(fd,"            for (int i=0,j=0;i<%d;i++,j+=2) {\n",M);
+            // First 16 LLRs of first CN
+        fprintf(fd,"            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);\n");
+        fprintf(fd,"            ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);\n");
+
+            // Loop over CNs
+        for (k=1; k<2; k++)
+        {
+        fprintf(fd,"            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[%d + j]);\n", k*cnOffsetInGroup);
+        fprintf(fd,"            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);\n");
+
+        fprintf(fd,"            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[%d + j +1]);\n", k*cnOffsetInGroup);
+
+        fprintf(fd, "           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); \n");
+        }
+
+            // Add LLR from receiver input
+        fprintf(fd,"            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);\n");
+        fprintf(fd,"            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);\n");
+
+        fprintf(fd,"            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);\n");
+        fprintf(fd,"            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);\n");
+
+            // Pack results back to epi8
+        fprintf(fd,"            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);\n");
+            // ymm0     = [ymmRes1[255:128] ymmRes0[255:128] ymmRes1[127:0] ymmRes0[127:0]]
+            // p_llrRes = [ymmRes1[255:128] ymmRes1[127:0] ymmRes0[255:128] ymmRes0[127:0]]
+        fprintf(fd,"            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);\n");
+        fprintf(fd,"             p_llrRes++;\n");
+
+        fprintf(fd,"}\n");
+    }
+
+    // =====================================================================
+    // Process group with 3 CNs
+
+
+fprintf(fd,  "// Process group with 3 CNs \n");
+
+ // Process group with 3 CNs
+
+    if (lut_numBnInBnGroups[2] > 0)
+    {
+        // If elements in group move to next address
+        idxBnGroup++;
+
+        // Number of groups of 32 BNs for parallel processing
+        M = (lut_numBnInBnGroups[2]*Z + 31)>>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 2
+        fprintf(fd,"    p_bnProcBuf     = (__m128i*) &bnProcBuf    [%d];\n",lut_startAddrBnGroups[idxBnGroup]);
+        fprintf(fd,"    p_llrProcBuf    = (__m128i*) &llrProcBuf   [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+        fprintf(fd,"    p_llrRes        = (__m256i*) &llrRes       [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+        // Loop over BNs
+        fprintf(fd,"        for (int i=0,j=0;i<%d;i++,j+=2) {\n",M);
+            // First 16 LLRs of first CN
+        fprintf(fd,"        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);\n");
+        fprintf(fd,"        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);\n");
+
+            // Loop over CNs
+        for (k=1; k<3; k++)
+        {
+        fprintf(fd,"        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[%d + j]);\n", k*cnOffsetInGroup);
+        fprintf(fd,"        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);\n");
+
+        fprintf(fd,"        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[%d + j +1]);\n", k*cnOffsetInGroup);
+
+        fprintf(fd,"        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); \n");
+            }
+
+            // Add LLR from receiver input
+        fprintf(fd,"        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);\n");
+        fprintf(fd,"        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);\n");
+
+        fprintf(fd,"        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);\n");
+        fprintf(fd,"        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);\n");
+
+            // Pack results back to epi8
+        fprintf(fd,"        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);\n");
+            // ymm0     = [ymmRes1[255:128] ymmRes0[255:128] ymmRes1[127:0] ymmRes0[127:0]]
+        fprintf(fd,"            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);\n");
+        fprintf(fd,"             p_llrRes++;\n");
+        fprintf(fd,"}\n");
+    }
+
+
+
+    // =====================================================================
+    // Process group with 4 CNs
+
+fprintf(fd,  "// Process group with 4 CNs \n");
+
+ // Process group with 4 CNs
+
+    if (lut_numBnInBnGroups[3] > 0)
+    {
+        // If elements in group move to next address
+        idxBnGroup++;
+
+        // Number of groups of 32 BNs for parallel processing
+        M = (lut_numBnInBnGroups[3]*Z + 31)>>5;
+
+        // Set the offset to each CN within a group in terms of 16 Byte
+        cnOffsetInGroup = (lut_numBnInBnGroups[3]*NR_LDPC_ZMAX)>>4;
+
+        // Set pointers to start of group 2
+        fprintf(fd,"    p_bnProcBuf     = (__m128i*) &bnProcBuf    [%d];\n",lut_startAddrBnGroups[idxBnGroup]);
+        fprintf(fd,"    p_llrProcBuf    = (__m128i*) &llrProcBuf   [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+        fprintf(fd,"    p_llrRes        = (__m256i*) &llrRes       [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+
+        // Loop over BNs
+        fprintf(fd,"        for (int i=0,j=0;i<%d;i++,j+=2) {\n",M);
+            // First 16 LLRs of first CN
+        fprintf(fd,"        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);\n");
+        fprintf(fd,"        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);\n");
+
+            // Loop over CNs
+        for (k=1; k<4; k++)
+        {
+        fprintf(fd,"        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[%d + j]);\n", k*cnOffsetInGroup);
+        fprintf(fd,"        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);\n");
+
+        fprintf(fd,"        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[%d + j +1]);\n", k*cnOffsetInGroup);
+
+        fprintf(fd, "       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); \n");
+        }
+
+            // Add LLR from receiver input
+        fprintf(fd,"        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);\n");
+        fprintf(fd,"        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);\n");
+
+        fprintf(fd,"        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);\n");
+        fprintf(fd,"        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);\n");
+
+            // Pack results back to epi8
+        fprintf(fd,"        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);\n");
+            // ymm0     = [ymmRes1[255:128] ymmRes0[255:128] ymmRes1[127:0] ymmRes0[127:0]]
+            // p_llrRes = [ymmRes1[255:128] ymmRes1[127:0] ymmRes0[255:128] ymmRes0[127:0]]
+        fprintf(fd,"            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);\n");
+        fprintf(fd,"             p_llrRes++;\n");
+        fprintf(fd,"}\n");
+    }
+
+
+   // =====================================================================
+    // Process group with 5 CNs
+    
+fprintf(fd,  "// Process group with 5 CNs \n");
+
+ // Process group with 5 CNs
+
+    if (lut_numBnInBnGroups[4] > 0)
+    {
+        // If elements in group move to next address
+        idxBnGroup++;
+
+        // Number of groups of 32 BNs for parallel processing
+        M = (lut_numBnInBnGroups[4]*Z + 31)>>5;
+
+        // Set the offset to each CN within a group in terms of 16 Byte
+        cnOffsetInGroup = (lut_numBnInBnGroups[4]*NR_LDPC_ZMAX)>>4;
+
+        // Set pointers to start of group 2
+        fprintf(fd,"    p_bnProcBuf     = (__m128i*) &bnProcBuf    [%d];\n",lut_startAddrBnGroups[idxBnGroup]);
+        fprintf(fd,"    p_llrProcBuf    = (__m128i*) &llrProcBuf   [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+        fprintf(fd,"    p_llrRes        = (__m256i*) &llrRes       [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+        // Loop over BNs
+        fprintf(fd,"        for (int i=0,j=0;i<%d;i++,j+=2) {\n",M);
+            // First 16 LLRs of first CN
+        fprintf(fd,"        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);\n");
+        fprintf(fd,"        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);\n");
+
+            // Loop over CNs
+        for (k=1; k<5; k++)
+        {
+        fprintf(fd,"        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[%d + j]);\n", k*cnOffsetInGroup);
+        fprintf(fd,"        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);\n");
+
+        fprintf(fd,"        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[%d + j +1]);\n", k*cnOffsetInGroup);
+
+        fprintf(fd, "       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); \n");
+        }
+
+            // Add LLR from receiver input
+        fprintf(fd,"        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);\n");
+        fprintf(fd,"        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);\n");
+
+        fprintf(fd,"        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);\n");
+        fprintf(fd,"        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);\n");
+
+            // Pack results back to epi8
+        fprintf(fd,"        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);\n");
+            // ymm0     = [ymmRes1[255:128] ymmRes0[255:128] ymmRes1[127:0] ymmRes0[127:0]]
+            // p_llrRes = [ymmRes1[255:128] ymmRes1[127:0] ymmRes0[255:128] ymmRes0[127:0]]
+        fprintf(fd,"            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);\n");
+        fprintf(fd,"             p_llrRes++;\n");
+        fprintf(fd,"}\n");
+    }
+
+
+
+   // =====================================================================
+    // Process group with 6 CNs
+    
+fprintf(fd,  "// Process group with 6 CNs \n");
+
+ // Process group with 6 CNs
+
+    if (lut_numBnInBnGroups[5] > 0)
+    {
+        // If elements in group move to next address
+        idxBnGroup++;
+
+        // Number of groups of 32 BNs for parallel processing
+        M = (lut_numBnInBnGroups[5]*Z + 31)>>5;
+
+        // Set the offset to each CN within a group in terms of 16 Byte
+        cnOffsetInGroup = (lut_numBnInBnGroups[5]*NR_LDPC_ZMAX)>>4;
+
+        // Set pointers to start of group 2
+        fprintf(fd,"    p_bnProcBuf     = (__m128i*) &bnProcBuf    [%d];\n",lut_startAddrBnGroups[idxBnGroup]);
+        fprintf(fd,"    p_llrProcBuf    = (__m128i*) &llrProcBuf   [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+        fprintf(fd,"    p_llrRes        = (__m256i*) &llrRes       [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+        // Loop over BNs
+        fprintf(fd,"        for (int i=0,j=0;i<%d;i++,j+=2) {\n",M);
+            // First 16 LLRs of first CN
+        fprintf(fd,"        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);\n");
+        fprintf(fd,"        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);\n");
+
+            // Loop over CNs
+        for (k=1; k<6; k++)
+        {
+        fprintf(fd,"        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[%d + j]);\n", k*cnOffsetInGroup);
+        fprintf(fd,"        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);\n");
+
+        fprintf(fd,"        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[%d + j +1]);\n", k*cnOffsetInGroup);
+
+        fprintf(fd, "       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); \n");
+        }
+
+            // Add LLR from receiver input
+        fprintf(fd,"        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);\n");
+        fprintf(fd,"        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);\n");
+
+        fprintf(fd,"        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);\n");
+        fprintf(fd,"        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);\n");
+
+            // Pack results back to epi8
+        fprintf(fd,"        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);\n");
+            // ymm0     = [ymmRes1[255:128] ymmRes0[255:128] ymmRes1[127:0] ymmRes0[127:0]]
+            // p_llrRes = [ymmRes1[255:128] ymmRes1[127:0] ymmRes0[255:128] ymmRes0[127:0]]
+        fprintf(fd,"            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);\n");
+        fprintf(fd,"             p_llrRes++;\n");
+        fprintf(fd,"}\n");
+    }
+
+
+   // =====================================================================
+    // Process group with 7 CNs
+    
+fprintf(fd,  "// Process group with 7 CNs \n");
+
+ // Process group with 7 CNs
+
+    if (lut_numBnInBnGroups[6] > 0)
+    {
+        // If elements in group move to next address
+        idxBnGroup++;
+
+        // Number of groups of 32 BNs for parallel processing
+        M = (lut_numBnInBnGroups[6]*Z + 31)>>5;
+
+        // Set the offset to each CN within a group in terms of 16 Byte
+        cnOffsetInGroup = (lut_numBnInBnGroups[6]*NR_LDPC_ZMAX)>>4;
+
+        // Set pointers to start of group 2
+        fprintf(fd,"    p_bnProcBuf     = (__m128i*) &bnProcBuf    [%d];\n",lut_startAddrBnGroups[idxBnGroup]);
+        fprintf(fd,"    p_llrProcBuf    = (__m128i*) &llrProcBuf   [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+        fprintf(fd,"    p_llrRes        = (__m256i*) &llrRes       [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+        // Loop over BNs
+        fprintf(fd,"        for (int i=0,j=0;i<%d;i++,j+=2) {\n",M);
+            // First 16 LLRs of first CN
+        fprintf(fd,"        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);\n");
+        fprintf(fd,"        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);\n");
+
+            // Loop over CNs
+        for (k=1; k<7; k++)
+        {
+        fprintf(fd,"        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[%d + j]);\n", k*cnOffsetInGroup);
+        fprintf(fd,"        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);\n");
+
+        fprintf(fd,"        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[%d + j +1]);\n", k*cnOffsetInGroup);
+
+        fprintf(fd, "       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); \n");
+        }
+
+            // Add LLR from receiver input
+        fprintf(fd,"        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);\n");
+        fprintf(fd,"        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);\n");
+
+        fprintf(fd,"        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);\n");
+        fprintf(fd,"        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);\n");
+
+            // Pack results back to epi8
+        fprintf(fd,"        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);\n");
+            // ymm0     = [ymmRes1[255:128] ymmRes0[255:128] ymmRes1[127:0] ymmRes0[127:0]]
+            // p_llrRes = [ymmRes1[255:128] ymmRes1[127:0] ymmRes0[255:128] ymmRes0[127:0]]
+        //fprintf(fd,"         (__m256i*) &llrRes[%d + i]    = _mm256_permute4x64_epi64(ymm0, 0xD8);\n",lut_startAddrBnGroupsLlr[idxBnGroup]>>5 );
+        fprintf(fd,"            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);\n");
+        fprintf(fd,"             p_llrRes++;\n");
+        fprintf(fd,"}\n");
+    }
+
+
+   // =====================================================================
+    // Process group with 8 CNs
+    
+fprintf(fd,  "// Process group with 8 CNs \n");
+
+ // Process group with 8 CNs
+
+    if (lut_numBnInBnGroups[7] > 0)
+    {
+        // If elements in group move to next address
+        idxBnGroup++;
+
+        // Number of groups of 32 BNs for parallel processing
+        M = (lut_numBnInBnGroups[7]*Z + 31)>>5;
+
+        // Set the offset to each CN within a group in terms of 16 Byte
+        cnOffsetInGroup = (lut_numBnInBnGroups[7]*NR_LDPC_ZMAX)>>4;
+
+        // Set pointers to start of group 2
+        fprintf(fd,"    p_bnProcBuf     = (__m128i*) &bnProcBuf    [%d];\n",lut_startAddrBnGroups[idxBnGroup]);
+        fprintf(fd,"    p_llrProcBuf    = (__m128i*) &llrProcBuf   [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+        fprintf(fd,"    p_llrRes        = (__m256i*) &llrRes       [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+        // Loop over BNs
+        fprintf(fd,"        for (int i=0,j=0;i<%d;i++,j+=2) {\n",M);
+            // First 16 LLRs of first CN
+        fprintf(fd,"        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);\n");
+        fprintf(fd,"        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);\n");
+
+            // Loop over CNs
+        for (k=1; k<8; k++)
+        {
+        fprintf(fd,"        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[%d + j]);\n", k*cnOffsetInGroup);
+        fprintf(fd,"        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);\n");
+
+        fprintf(fd,"        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[%d + j +1]);\n", k*cnOffsetInGroup);
+
+        fprintf(fd, "       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); \n");
+        }
+
+            // Add LLR from receiver input
+        fprintf(fd,"        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);\n");
+        fprintf(fd,"        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);\n");
+
+        fprintf(fd,"        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);\n");
+        fprintf(fd,"        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);\n");
+
+            // Pack results back to epi8
+        fprintf(fd,"        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);\n");
+            // ymm0     = [ymmRes1[255:128] ymmRes0[255:128] ymmRes1[127:0] ymmRes0[127:0]]
+            // p_llrRes = [ymmRes1[255:128] ymmRes1[127:0] ymmRes0[255:128] ymmRes0[127:0]]
+        //fprintf(fd,"         (__m256i*) &llrRes[%d + i]    = _mm256_permute4x64_epi64(ymm0, 0xD8);\n",lut_startAddrBnGroupsLlr[idxBnGroup]>>5 );
+
+        fprintf(fd,"            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);\n");
+        fprintf(fd,"             p_llrRes++;\n");
+        fprintf(fd,"}\n");
+    }
+
+   // =====================================================================
+    // Process group with 9 CNs
+    
+fprintf(fd,  "// Process group with 9 CNs \n");
+
+ // Process group with 9 CNs
+
+    if (lut_numBnInBnGroups[8] > 0)
+    {
+        // If elements in group move to next address
+        idxBnGroup++;
+
+        // Number of groups of 32 BNs for parallel processing
+        M = (lut_numBnInBnGroups[8]*Z + 31)>>5;
+
+        // Set the offset to each CN within a group in terms of 16 Byte
+        cnOffsetInGroup = (lut_numBnInBnGroups[8]*NR_LDPC_ZMAX)>>4;
+
+        // Set pointers to start of group 2
+        fprintf(fd,"    p_bnProcBuf     = (__m128i*) &bnProcBuf    [%d];\n",lut_startAddrBnGroups[idxBnGroup]);
+        fprintf(fd,"    p_llrProcBuf    = (__m128i*) &llrProcBuf   [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+        fprintf(fd,"    p_llrRes        = (__m256i*) &llrRes       [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+        // Loop over BNs
+        fprintf(fd,"        for (int i=0,j=0;i<%d;i++,j+=2) {\n",M);
+            // First 16 LLRs of first CN
+        fprintf(fd,"        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);\n");
+        fprintf(fd,"        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);\n");
+
+            // Loop over CNs
+        for (k=1; k<9; k++)
+        {
+        fprintf(fd,"        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[%d + j]);\n", k*cnOffsetInGroup);
+        fprintf(fd,"        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);\n");
+
+        fprintf(fd,"        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[%d + j +1]);\n", k*cnOffsetInGroup);
+
+        fprintf(fd, "       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); \n");
+        }
+
+            // Add LLR from receiver input
+        fprintf(fd,"        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);\n");
+        fprintf(fd,"        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);\n");
+
+        fprintf(fd,"        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);\n");
+        fprintf(fd,"        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);\n");
+
+            // Pack results back to epi8
+        fprintf(fd,"        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);\n");
+            // ymm0     = [ymmRes1[255:128] ymmRes0[255:128] ymmRes1[127:0] ymmRes0[127:0]]
+            // p_llrRes = [ymmRes1[255:128] ymmRes1[127:0] ymmRes0[255:128] ymmRes0[127:0]]
+        //fprintf(fd,"         (__m256i*) &llrRes[%d + i]    = _mm256_permute4x64_epi64(ymm0, 0xD8);\n",lut_startAddrBnGroupsLlr[idxBnGroup]>>5 );
+        fprintf(fd,"            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);\n");
+        fprintf(fd,"             p_llrRes++;\n");
+        fprintf(fd,"}\n");
+    }
+
+
+   // =====================================================================
+    // Process group with 10 CNs
+    
+fprintf(fd,  "// Process group with 10 CNs \n");
+
+ // Process group with 10 CNs
+
+    if (lut_numBnInBnGroups[9] > 0)
+    {
+        // If elements in group move to next address
+        idxBnGroup++;
+
+        // Number of groups of 32 BNs for parallel processing
+        M = (lut_numBnInBnGroups[9]*Z + 31)>>5;
+
+        // Set the offset to each CN within a group in terms of 16 Byte
+        cnOffsetInGroup = (lut_numBnInBnGroups[9]*NR_LDPC_ZMAX)>>4;
+
+        // Set pointers to start of group 2
+        fprintf(fd,"    p_bnProcBuf     = (__m128i*) &bnProcBuf    [%d];\n",lut_startAddrBnGroups[idxBnGroup]);
+        fprintf(fd,"    p_llrProcBuf    = (__m128i*) &llrProcBuf   [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+        fprintf(fd,"    p_llrRes        = (__m256i*) &llrRes       [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+        // Loop over BNs
+        fprintf(fd,"        for (int i=0,j=0;i<%d;i++,j+=2) {\n",M);
+            // First 16 LLRs of first CN
+        fprintf(fd,"        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);\n");
+        fprintf(fd,"        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);\n");
+
+            // Loop over CNs
+        for (k=1; k<10; k++)
+        {
+        fprintf(fd,"        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[%d + j]);\n", k*cnOffsetInGroup);
+        fprintf(fd,"        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);\n");
+
+        fprintf(fd,"        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[%d + j +1]);\n", k*cnOffsetInGroup);
+
+        fprintf(fd, "       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); \n");
+        }
+
+            // Add LLR from receiver input
+        fprintf(fd,"        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);\n");
+        fprintf(fd,"        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);\n");
+
+        fprintf(fd,"        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);\n");
+        fprintf(fd,"        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);\n");
+
+            // Pack results back to epi8
+        fprintf(fd,"        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);\n");
+            // ymm0     = [ymmRes1[255:128] ymmRes0[255:128] ymmRes1[127:0] ymmRes0[127:0]]
+            // p_llrRes = [ymmRes1[255:128] ymmRes1[127:0] ymmRes0[255:128] ymmRes0[127:0]]
+        fprintf(fd,"            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);\n");
+        fprintf(fd,"             p_llrRes++;\n");
+        fprintf(fd,"}\n");
+    }
+
+
+
+    // =====================================================================
+   
+fprintf(fd,  "// Process group with 11 CNs \n");
+
+
+
+ // Process group with 2 CNs
+
+    if (lut_numBnInBnGroups[10] > 0)
+    {
+        // If elements in group move to next address
+        idxBnGroup++;
+
+        // Number of groups of 32 BNs for parallel processing
+        M = (lut_numBnInBnGroups[10]*Z + 31)>>5;
+
+        // Set the offset to each CN within a group in terms of 16 Byte
+        cnOffsetInGroup = (lut_numBnInBnGroups[10]*NR_LDPC_ZMAX)>>4;
+
+        // Set pointers to start of group 2
+        fprintf(fd,"    p_bnProcBuf     = (__m128i*) &bnProcBuf    [%d];\n",lut_startAddrBnGroups[idxBnGroup]);
+        fprintf(fd,"    p_llrProcBuf    = (__m128i*) &llrProcBuf   [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+        fprintf(fd,"    p_llrRes        = (__m256i*) &llrRes       [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+        // Loop over BNs
+        fprintf(fd,"            for (int i=0,j=0;i<%d;i++,j+=2) {\n",M);
+            // First 16 LLRs of first CN
+        fprintf(fd,"            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);\n");
+        fprintf(fd,"            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);\n");
+
+            // Loop over CNs
+        for (k=1; k<11; k++)
+        {
+        fprintf(fd,"            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[%d + j]);\n", k*cnOffsetInGroup);
+        fprintf(fd,"            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);\n");
+
+        fprintf(fd,"            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[%d + j +1]);\n", k*cnOffsetInGroup);
+
+        fprintf(fd, "           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); \n");
+        }
+
+            // Add LLR from receiver input
+        fprintf(fd,"            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);\n");
+        fprintf(fd,"            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);\n");
+
+        fprintf(fd,"            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);\n");
+        fprintf(fd,"            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);\n");
+
+            // Pack results back to epi8
+        fprintf(fd,"            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);\n");
+            // ymm0     = [ymmRes1[255:128] ymmRes0[255:128] ymmRes1[127:0] ymmRes0[127:0]]
+            // p_llrRes = [ymmRes1[255:128] ymmRes1[127:0] ymmRes0[255:128] ymmRes0[127:0]]
+        fprintf(fd,"            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);\n");
+        fprintf(fd,"             p_llrRes++;\n");
+        fprintf(fd,"}\n");
+    }
+      // =====================================================================
+    // Process group with 2 CNs
+
+
+fprintf(fd,  "// Process group with 12 CNs \n");
+
+ // Process group with 2 CNs
+
+    if (lut_numBnInBnGroups[11] > 0)
+    {
+        // If elements in group move to next address
+        idxBnGroup++;
+
+        // Number of groups of 32 BNs for parallel processing
+        M = (lut_numBnInBnGroups[11]*Z + 31)>>5;
+
+        // Set the offset to each CN within a group in terms of 16 Byte
+        cnOffsetInGroup = (lut_numBnInBnGroups[11]*NR_LDPC_ZMAX)>>4;
+
+        // Set pointers to start of group 2
+        fprintf(fd,"    p_bnProcBuf     = (__m128i*) &bnProcBuf    [%d];\n",lut_startAddrBnGroups[idxBnGroup]);
+        fprintf(fd,"    p_llrProcBuf    = (__m128i*) &llrProcBuf   [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+        fprintf(fd,"    p_llrRes        = (__m256i*) &llrRes       [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+        // Loop over BNs
+        fprintf(fd,"            for (int i=0,j=0;i<%d;i++,j+=2) {\n",M);
+            // First 16 LLRs of first CN
+        fprintf(fd,"            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);\n");
+        fprintf(fd,"            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);\n");
+
+            // Loop over CNs
+        for (k=1; k<12; k++)
+        {
+        fprintf(fd,"            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[%d + j]);\n", k*cnOffsetInGroup);
+        fprintf(fd,"            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);\n");
+
+        fprintf(fd,"            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[%d + j +1]);\n", k*cnOffsetInGroup);
+
+        fprintf(fd, "           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); \n");
+        }
+
+            // Add LLR from receiver input
+        fprintf(fd,"            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);\n");
+        fprintf(fd,"            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);\n");
+
+        fprintf(fd,"            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);\n");
+        fprintf(fd,"            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);\n");
+
+            // Pack results back to epi8
+        fprintf(fd,"            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);\n");
+            // ymm0     = [ymmRes1[255:128] ymmRes0[255:128] ymmRes1[127:0] ymmRes0[127:0]]
+            // p_llrRes = [ymmRes1[255:128] ymmRes1[127:0] ymmRes0[255:128] ymmRes0[127:0]]
+        fprintf(fd,"            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);\n");
+        fprintf(fd,"             p_llrRes++;\n");
+        fprintf(fd,"}\n");
+    }
+
+    // =====================================================================
+    // Process group with 13 CNs
+
+
+fprintf(fd,  "// Process group with 13 CNs \n");
+
+ // Process group with 3 CNs
+
+    if (lut_numBnInBnGroups[12] > 0)
+    {
+        // If elements in group move to next address
+        idxBnGroup++;
+
+        // Number of groups of 32 BNs for parallel processing
+        M = (lut_numBnInBnGroups[12]*Z + 31)>>5;
+
+        // Set the offset to each CN within a group in terms of 16 Byte
+        cnOffsetInGroup = (lut_numBnInBnGroups[12]*NR_LDPC_ZMAX)>>4;
+
+        // Set pointers to start of group 2
+        fprintf(fd,"    p_bnProcBuf     = (__m128i*) &bnProcBuf    [%d];\n",lut_startAddrBnGroups[idxBnGroup]);
+        fprintf(fd,"    p_llrProcBuf    = (__m128i*) &llrProcBuf   [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+        fprintf(fd,"    p_llrRes        = (__m256i*) &llrRes       [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+        // Loop over BNs
+        fprintf(fd,"        for (int i=0,j=0;i<%d;i++,j+=2) {\n",M);
+            // First 16 LLRs of first CN
+        fprintf(fd,"        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);\n");
+        fprintf(fd,"        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);\n");
+
+            // Loop over CNs
+        for (k=1; k<13; k++)
+        {
+        fprintf(fd,"        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[%d + j]);\n", k*cnOffsetInGroup);
+        fprintf(fd,"        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);\n");
+
+        fprintf(fd,"        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[%d + j +1]);\n", k*cnOffsetInGroup);
+
+        fprintf(fd,"        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); \n");
+            }
+
+            // Add LLR from receiver input
+        fprintf(fd,"        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);\n");
+        fprintf(fd,"        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);\n");
+
+        fprintf(fd,"        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);\n");
+        fprintf(fd,"        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);\n");
+
+            // Pack results back to epi8
+        fprintf(fd,"        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);\n");
+            // ymm0     = [ymmRes1[255:128] ymmRes0[255:128] ymmRes1[127:0] ymmRes0[127:0]]
+            // p_llrRes = [ymmRes1[255:128] ymmRes1[127:0] ymmRes0[255:128] ymmRes0[127:0]]
+        fprintf(fd,"            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);\n");
+        fprintf(fd,"             p_llrRes++;\n");
+        fprintf(fd,"}\n");
+    }
+
+
+
+    // =====================================================================
+    // Process group with 4 CNs
+
+fprintf(fd,  "// Process group with 14 CNs \n");
+
+ // Process group with 4 CNs
+
+    if (lut_numBnInBnGroups[13] > 0)
+    {
+        // If elements in group move to next address
+        idxBnGroup++;
+
+        // Number of groups of 32 BNs for parallel processing
+        M = (lut_numBnInBnGroups[13]*Z + 31)>>5;
+
+        // Set the offset to each CN within a group in terms of 16 Byte
+        cnOffsetInGroup = (lut_numBnInBnGroups[13]*NR_LDPC_ZMAX)>>4;
+
+        // Set pointers to start of group 2
+        fprintf(fd,"    p_bnProcBuf     = (__m128i*) &bnProcBuf    [%d];\n",lut_startAddrBnGroups[idxBnGroup]);
+        fprintf(fd,"    p_llrProcBuf    = (__m128i*) &llrProcBuf   [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+        fprintf(fd,"    p_llrRes        = (__m256i*) &llrRes       [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+        // Loop over BNs
+        fprintf(fd,"        for (int i=0,j=0;i<%d;i++,j+=2) {\n",M);
+            // First 16 LLRs of first CN
+        fprintf(fd,"        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);\n");
+        fprintf(fd,"        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);\n");
+
+            // Loop over CNs
+        for (k=1; k<14; k++)
+        {
+        fprintf(fd,"        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[%d + j]);\n", k*cnOffsetInGroup);
+        fprintf(fd,"        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);\n");
+
+        fprintf(fd,"        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[%d + j +1]);\n", k*cnOffsetInGroup);
+
+        fprintf(fd, "       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); \n");
+        }
+
+            // Add LLR from receiver input
+        fprintf(fd,"        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);\n");
+        fprintf(fd,"        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);\n");
+
+        fprintf(fd,"        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);\n");
+        fprintf(fd,"        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);\n");
+
+            // Pack results back to epi8
+        fprintf(fd,"        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);\n");
+            // ymm0     = [ymmRes1[255:128] ymmRes0[255:128] ymmRes1[127:0] ymmRes0[127:0]]
+            // p_llrRes = [ymmRes1[255:128] ymmRes1[127:0] ymmRes0[255:128] ymmRes0[127:0]]
+        fprintf(fd,"            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);\n");
+        fprintf(fd,"             p_llrRes++;\n");
+        fprintf(fd,"}\n");
+    }
+
+
+   // =====================================================================
+    // Process group with 5 CNs
+    
+fprintf(fd,  "// Process group with 15 CNs \n");
+
+ // Process group with 5 CNs
+
+    if (lut_numBnInBnGroups[14] > 0)
+    {
+        // If elements in group move to next address
+        idxBnGroup++;
+
+        // Number of groups of 32 BNs for parallel processing
+        M = (lut_numBnInBnGroups[14]*Z + 31)>>5;
+
+        // Set the offset to each CN within a group in terms of 16 Byte
+        cnOffsetInGroup = (lut_numBnInBnGroups[14]*NR_LDPC_ZMAX)>>4;
+
+        // Set pointers to start of group 2
+        fprintf(fd,"    p_bnProcBuf     = (__m128i*) &bnProcBuf    [%d];\n",lut_startAddrBnGroups[idxBnGroup]);
+        fprintf(fd,"    p_llrProcBuf    = (__m128i*) &llrProcBuf   [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+        fprintf(fd,"    p_llrRes        = (__m256i*) &llrRes       [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+        // Loop over BNs
+        fprintf(fd,"        for (int i=0,j=0;i<%d;i++,j+=2) {\n",M);
+            // First 16 LLRs of first CN
+        fprintf(fd,"        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);\n");
+        fprintf(fd,"        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);\n");
+
+            // Loop over CNs
+        for (k=1; k<15; k++)
+        {
+        fprintf(fd,"        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[%d + j]);\n", k*cnOffsetInGroup);
+        fprintf(fd,"        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);\n");
+
+        fprintf(fd,"        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[%d + j +1]);\n", k*cnOffsetInGroup);
+
+        fprintf(fd, "       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); \n");
+        }
+
+            // Add LLR from receiver input
+        fprintf(fd,"        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);\n");
+        fprintf(fd,"        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);\n");
+
+        fprintf(fd,"        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);\n");
+        fprintf(fd,"        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);\n");
+
+            // Pack results back to epi8
+        fprintf(fd,"        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);\n");
+            // ymm0     = [ymmRes1[255:128] ymmRes0[255:128] ymmRes1[127:0] ymmRes0[127:0]]
+            // p_llrRes = [ymmRes1[255:128] ymmRes1[127:0] ymmRes0[255:128] ymmRes0[127:0]]
+         fprintf(fd,"            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);\n");
+        fprintf(fd,"             p_llrRes++;\n");
+        fprintf(fd,"}\n");
+    }
+
+
+
+   // =====================================================================
+    // Process group with 6 CNs
+    
+fprintf(fd,  "// Process group with 16 CNs \n");
+
+ // Process group with 6 CNs
+
+    if (lut_numBnInBnGroups[15] > 0)
+    {
+        // If elements in group move to next address
+        idxBnGroup++;
+
+        // Number of groups of 32 BNs for parallel processing
+        M = (lut_numBnInBnGroups[15]*Z + 31)>>5;
+
+        // Set the offset to each CN within a group in terms of 16 Byte
+        cnOffsetInGroup = (lut_numBnInBnGroups[15]*NR_LDPC_ZMAX)>>4;
+
+        // Set pointers to start of group 2
+        fprintf(fd,"    p_bnProcBuf     = (__m128i*) &bnProcBuf    [%d];\n",lut_startAddrBnGroups[idxBnGroup]);
+        fprintf(fd,"    p_llrProcBuf    = (__m128i*) &llrProcBuf   [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+        fprintf(fd,"    p_llrRes        = (__m256i*) &llrRes       [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+        // Loop over BNs
+        fprintf(fd,"        for (int i=0,j=0;i<%d;i++,j+=2) {\n",M);
+            // First 16 LLRs of first CN
+        fprintf(fd,"        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);\n");
+        fprintf(fd,"        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);\n");
+
+            // Loop over CNs
+        for (k=1; k<16; k++)
+        {
+        fprintf(fd,"        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[%d + j]);\n", k*cnOffsetInGroup);
+        fprintf(fd,"        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);\n");
+
+        fprintf(fd,"        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[%d + j +1]);\n", k*cnOffsetInGroup);
+
+        fprintf(fd, "       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); \n");
+        }
+
+            // Add LLR from receiver input
+        fprintf(fd,"        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);\n");
+        fprintf(fd,"        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);\n");
+
+        fprintf(fd,"        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);\n");
+        fprintf(fd,"        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);\n");
+
+            // Pack results back to epi8
+        fprintf(fd,"        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);\n");
+            // ymm0     = [ymmRes1[255:128] ymmRes0[255:128] ymmRes1[127:0] ymmRes0[127:0]]
+            // p_llrRes = [ymmRes1[255:128] ymmRes1[127:0] ymmRes0[255:128] ymmRes0[127:0]]
+        fprintf(fd,"            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);\n");
+        fprintf(fd,"             p_llrRes++;\n");
+        fprintf(fd,"}\n");
+    }
+
+
+   // =====================================================================
+    // Process group with 17 CNs
+    
+fprintf(fd,  "// Process group with 17 CNs \n");
+
+ // Process group with 17 CNs
+
+    if (lut_numBnInBnGroups[16] > 0)
+    {
+        // If elements in group move to next address
+        idxBnGroup++;
+
+        // Number of groups of 32 BNs for parallel processing
+        M = (lut_numBnInBnGroups[16]*Z + 31)>>5;
+
+        // Set the offset to each CN within a group in terms of 16 Byte
+        cnOffsetInGroup = (lut_numBnInBnGroups[16]*NR_LDPC_ZMAX)>>4;
+
+        // Set pointers to start of group 2
+        fprintf(fd,"    p_bnProcBuf     = (__m128i*) &bnProcBuf    [%d];\n",lut_startAddrBnGroups[idxBnGroup]);
+        fprintf(fd,"    p_llrProcBuf    = (__m128i*) &llrProcBuf   [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+        fprintf(fd,"    p_llrRes        = (__m256i*) &llrRes       [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+        // Loop over BNs
+        fprintf(fd,"        for (int i=0,j=0;i<%d;i++,j+=2) {\n",M);
+            // First 16 LLRs of first CN
+        fprintf(fd,"        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);\n");
+        fprintf(fd,"        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);\n");
+
+            // Loop over CNs
+        for (k=1; k<17; k++)
+        {
+        fprintf(fd,"        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[%d + j]);\n", k*cnOffsetInGroup);
+        fprintf(fd,"        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);\n");
+
+        fprintf(fd,"        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[%d + j +1]);\n", k*cnOffsetInGroup);
+
+        fprintf(fd, "       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); \n");
+        }
+
+            // Add LLR from receiver input
+        fprintf(fd,"        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);\n");
+        fprintf(fd,"        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);\n");
+
+        fprintf(fd,"        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);\n");
+        fprintf(fd,"        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);\n");
+
+            // Pack results back to epi8
+        fprintf(fd,"        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);\n");
+            // ymm0     = [ymmRes1[255:128] ymmRes0[255:128] ymmRes1[127:0] ymmRes0[127:0]]
+            // p_llrRes = [ymmRes1[255:128] ymmRes1[127:0] ymmRes0[255:128] ymmRes0[127:0]]
+        fprintf(fd,"            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);\n");
+        fprintf(fd,"             p_llrRes++;\n");
+        fprintf(fd,"}\n");
+    }
+
+
+   // =====================================================================
+    // Process group with 18 CNs
+    
+fprintf(fd,  "// Process group with 18 CNs \n");
+
+ // Process group with 8 CNs
+
+    if (lut_numBnInBnGroups[17] > 0)
+    {
+        // If elements in group move to next address
+        idxBnGroup++;
+
+        // Number of groups of 32 BNs for parallel processing
+        M = (lut_numBnInBnGroups[17]*Z + 31)>>5;
+
+        // Set the offset to each CN within a group in terms of 16 Byte
+        cnOffsetInGroup = (lut_numBnInBnGroups[17]*NR_LDPC_ZMAX)>>4;
+
+        // Set pointers to start of group 2
+        fprintf(fd,"    p_bnProcBuf     = (__m128i*) &bnProcBuf    [%d];\n",lut_startAddrBnGroups[idxBnGroup]);
+        fprintf(fd,"    p_llrProcBuf    = (__m128i*) &llrProcBuf   [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+        fprintf(fd,"    p_llrRes        = (__m256i*) &llrRes       [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+        // Loop over BNs
+        fprintf(fd,"        for (int i=0,j=0;i<%d;i++,j+=2) {\n",M);
+            // First 16 LLRs of first CN
+        fprintf(fd,"        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);\n");
+        fprintf(fd,"        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);\n");
+
+            // Loop over CNs
+        for (k=1; k<18; k++)
+        {
+        fprintf(fd,"        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[%d + j]);\n", k*cnOffsetInGroup);
+        fprintf(fd,"        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);\n");
+
+        fprintf(fd,"        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[%d + j +1]);\n", k*cnOffsetInGroup);
+
+        fprintf(fd, "       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); \n");
+        }
+
+            // Add LLR from receiver input
+        fprintf(fd,"        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);\n");
+        fprintf(fd,"        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);\n");
+
+        fprintf(fd,"        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);\n");
+        fprintf(fd,"        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);\n");
+
+            // Pack results back to epi8
+        fprintf(fd,"        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);\n");
+            // ymm0     = [ymmRes1[255:128] ymmRes0[255:128] ymmRes1[127:0] ymmRes0[127:0]]
+            // p_llrRes = [ymmRes1[255:128] ymmRes1[127:0] ymmRes0[255:128] ymmRes0[127:0]]
+        fprintf(fd,"            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);\n");
+        fprintf(fd,"             p_llrRes++;\n");
+        fprintf(fd,"}\n");
+    }
+
+   // =====================================================================
+    // Process group with 9 CNs
+    
+fprintf(fd,  "// Process group with 19 CNs \n");
+
+ // Process group with 9 CNs
+
+    if (lut_numBnInBnGroups[18] > 0)
+    {
+        // If elements in group move to next address
+        idxBnGroup++;
+
+        // Number of groups of 32 BNs for parallel processing
+        M = (lut_numBnInBnGroups[18]*Z + 31)>>5;
+
+        // Set the offset to each CN within a group in terms of 16 Byte
+        cnOffsetInGroup = (lut_numBnInBnGroups[18]*NR_LDPC_ZMAX)>>4;
+
+        // Set pointers to start of group 2
+        fprintf(fd,"    p_bnProcBuf     = (__m128i*) &bnProcBuf    [%d];\n",lut_startAddrBnGroups[idxBnGroup]);
+        fprintf(fd,"    p_llrProcBuf    = (__m128i*) &llrProcBuf   [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+        fprintf(fd,"    p_llrRes        = (__m256i*) &llrRes       [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+        // Loop over BNs
+        fprintf(fd,"        for (int i=0,j=0;i<%d;i++,j+=2) {\n",M);
+            // First 16 LLRs of first CN
+        fprintf(fd,"        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);\n");
+        fprintf(fd,"        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);\n");
+
+            // Loop over CNs
+        for (k=1; k<19; k++)
+        {
+        fprintf(fd,"        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[%d + j]);\n", k*cnOffsetInGroup);
+        fprintf(fd,"        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);\n");
+
+        fprintf(fd,"        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[%d + j +1]);\n", k*cnOffsetInGroup);
+
+        fprintf(fd, "       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); \n");
+        }
+
+            // Add LLR from receiver input
+        fprintf(fd,"        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);\n");
+        fprintf(fd,"        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);\n");
+
+        fprintf(fd,"        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);\n");
+        fprintf(fd,"        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);\n");
+
+            // Pack results back to epi8
+        fprintf(fd,"        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);\n");
+            // ymm0     = [ymmRes1[255:128] ymmRes0[255:128] ymmRes1[127:0] ymmRes0[127:0]]
+            // p_llrRes = [ymmRes1[255:128] ymmRes1[127:0] ymmRes0[255:128] ymmRes0[127:0]]
+        fprintf(fd,"            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);\n");
+        fprintf(fd,"             p_llrRes++;\n");
+        fprintf(fd,"}\n");
+    }
+
+
+   // =====================================================================
+    // Process group with 20 CNs
+    
+fprintf(fd,  "// Process group with 20 CNs \n");
+
+ // Process group with 20 CNs
+
+    if (lut_numBnInBnGroups[19] > 0)
+    {
+        // If elements in group move to next address
+        idxBnGroup++;
+
+        // Number of groups of 32 BNs for parallel processing
+        M = (lut_numBnInBnGroups[19]*Z + 31)>>5;
+
+        // Set the offset to each CN within a group in terms of 16 Byte
+        cnOffsetInGroup = (lut_numBnInBnGroups[19]*NR_LDPC_ZMAX)>>4;
+
+        // Set pointers to start of group 2
+        fprintf(fd,"    p_bnProcBuf     = (__m128i*) &bnProcBuf    [%d];\n",lut_startAddrBnGroups[idxBnGroup]);
+        fprintf(fd,"    p_llrProcBuf    = (__m128i*) &llrProcBuf   [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+        fprintf(fd,"    p_llrRes        = (__m256i*) &llrRes       [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+        // Loop over BNs
+        fprintf(fd,"        for (int i=0,j=0;i<%d;i++,j+=2) {\n",M);
+            // First 16 LLRs of first CN
+        fprintf(fd,"        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);\n");
+        fprintf(fd,"        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);\n");
+
+            // Loop over CNs
+        for (k=1; k<20; k++)
+        {
+        fprintf(fd,"        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[%d + j]);\n", k*cnOffsetInGroup);
+        fprintf(fd,"        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);\n");
+
+        fprintf(fd,"        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[%d + j +1]);\n", k*cnOffsetInGroup);
+
+        fprintf(fd, "       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); \n");
+        }
+
+            // Add LLR from receiver input
+        fprintf(fd,"        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);\n");
+        fprintf(fd,"        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);\n");
+
+        fprintf(fd,"        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);\n");
+        fprintf(fd,"        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);\n");
+
+            // Pack results back to epi8
+        fprintf(fd,"        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);\n");
+            // ymm0     = [ymmRes1[255:128] ymmRes0[255:128] ymmRes1[127:0] ymmRes0[127:0]]
+            // p_llrRes = [ymmRes1[255:128] ymmRes1[127:0] ymmRes0[255:128] ymmRes0[127:0]]
+        fprintf(fd,"            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);\n");
+        fprintf(fd,"             p_llrRes++;\n");
+        fprintf(fd,"}\n");
+    }
+
+
+
+
+
+    // =====================================================================
+   
+fprintf(fd,  "// Process group with 21 CNs \n");
+
+
+
+ // Process group with 2 CNs
+
+    if (lut_numBnInBnGroups[20] > 0)
+    {
+        // If elements in group move to next address
+        idxBnGroup++;
+
+        // Number of groups of 32 BNs for parallel processing
+        M = (lut_numBnInBnGroups[20]*Z + 31)>>5;
+
+        // Set the offset to each CN within a group in terms of 16 Byte
+        cnOffsetInGroup = (lut_numBnInBnGroups[20]*NR_LDPC_ZMAX)>>4;
+
+        // Set pointers to start of group 2
+        fprintf(fd,"    p_bnProcBuf     = (__m128i*) &bnProcBuf    [%d];\n",lut_startAddrBnGroups[idxBnGroup]);
+        fprintf(fd,"    p_llrProcBuf    = (__m128i*) &llrProcBuf   [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+        fprintf(fd,"    p_llrRes        = (__m256i*) &llrRes       [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+        // Loop over BNs
+        fprintf(fd,"            for (int i=0,j=0;i<%d;i++,j+=2) {\n",M);
+            // First 16 LLRs of first CN
+        fprintf(fd,"            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);\n");
+        fprintf(fd,"            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);\n");
+
+            // Loop over CNs
+        for (k=1; k<21; k++)
+        {
+        fprintf(fd,"            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[%d + j]);\n", k*cnOffsetInGroup);
+        fprintf(fd,"            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);\n");
+
+        fprintf(fd,"            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[%d + j +1]);\n", k*cnOffsetInGroup);
+
+        fprintf(fd, "           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); \n");
+        }
+
+            // Add LLR from receiver input
+        fprintf(fd,"            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);\n");
+        fprintf(fd,"            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);\n");
+
+        fprintf(fd,"            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);\n");
+        fprintf(fd,"            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);\n");
+
+            // Pack results back to epi8
+        fprintf(fd,"            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);\n");
+            // ymm0     = [ymmRes1[255:128] ymmRes0[255:128] ymmRes1[127:0] ymmRes0[127:0]]
+            // p_llrRes = [ymmRes1[255:128] ymmRes1[127:0] ymmRes0[255:128] ymmRes0[127:0]]
+        fprintf(fd,"            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);\n");
+        fprintf(fd,"             p_llrRes++;\n");
+        fprintf(fd,"}\n");
+    }
+      // =====================================================================
+    // Process group with 2 CNs
+
+
+fprintf(fd,  "// Process group with 22 CNs \n");
+
+ // Process group with 2 CNs
+
+    if (lut_numBnInBnGroups[21] > 0)
+    {
+        // If elements in group move to next address
+        idxBnGroup++;
+
+        // Number of groups of 32 BNs for parallel processing
+        M = (lut_numBnInBnGroups[21]*Z + 31)>>5;
+
+        // Set the offset to each CN within a group in terms of 16 Byte
+        cnOffsetInGroup = (lut_numBnInBnGroups[21]*NR_LDPC_ZMAX)>>4;
+
+        // Set pointers to start of group 2
+        fprintf(fd,"    p_bnProcBuf     = (__m128i*) &bnProcBuf    [%d];\n",lut_startAddrBnGroups[idxBnGroup]);
+        fprintf(fd,"    p_llrProcBuf    = (__m128i*) &llrProcBuf   [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+        fprintf(fd,"    p_llrRes        = (__m256i*) &llrRes       [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+        // Loop over BNs
+        fprintf(fd,"            for (int i=0,j=0;i<%d;i++,j+=2) {\n",M);
+            // First 16 LLRs of first CN
+        fprintf(fd,"            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);\n");
+        fprintf(fd,"            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);\n");
+
+            // Loop over CNs
+        for (k=1; k<22; k++)
+        {
+        fprintf(fd,"            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[%d + j]);\n", k*cnOffsetInGroup);
+        fprintf(fd,"            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);\n");
+
+        fprintf(fd,"            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[%d + j +1]);\n", k*cnOffsetInGroup);
+
+        fprintf(fd, "           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); \n");
+        }
+
+            // Add LLR from receiver input
+        fprintf(fd,"            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);\n");
+        fprintf(fd,"            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);\n");
+
+        fprintf(fd,"            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);\n");
+        fprintf(fd,"            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);\n");
+
+            // Pack results back to epi8
+        fprintf(fd,"            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);\n");
+            // ymm0     = [ymmRes1[255:128] ymmRes0[255:128] ymmRes1[127:0] ymmRes0[127:0]]
+            // p_llrRes = [ymmRes1[255:128] ymmRes1[127:0] ymmRes0[255:128] ymmRes0[127:0]]
+         fprintf(fd,"            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);\n");
+        fprintf(fd,"             p_llrRes++;\n");
+        fprintf(fd,"}\n");
+    }
+
+    // =====================================================================
+    // Process group with 13 CNs
+
+
+fprintf(fd,  "// Process group with <23 CNs \n");
+
+ // Process group with 3 CNs
+
+    if (lut_numBnInBnGroups[22] > 0)
+    {
+        // If elements in group move to next address
+        idxBnGroup++;
+
+        // Number of groups of 32 BNs for parallel processing
+        M = (lut_numBnInBnGroups[22]*Z + 31)>>5;
+
+        // Set the offset to each CN within a group in terms of 16 Byte
+        cnOffsetInGroup = (lut_numBnInBnGroups[22]*NR_LDPC_ZMAX)>>4;
+
+        // Set pointers to start of group 2
+        fprintf(fd,"    p_bnProcBuf     = (__m128i*) &bnProcBuf    [%d];\n",lut_startAddrBnGroups[idxBnGroup]);
+        fprintf(fd,"    p_llrProcBuf    = (__m128i*) &llrProcBuf   [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+        fprintf(fd,"    p_llrRes        = (__m256i*) &llrRes       [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+        // Loop over BNs
+        fprintf(fd,"        for (int i=0,j=0;i<%d;i++,j+=2) {\n",M);
+            // First 16 LLRs of first CN
+        fprintf(fd,"        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);\n");
+        fprintf(fd,"        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);\n");
+
+            // Loop over CNs
+        for (k=1; k<23; k++)
+        {
+        fprintf(fd,"        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[%d + j]);\n", k*cnOffsetInGroup);
+        fprintf(fd,"        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);\n");
+
+        fprintf(fd,"        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[%d + j +1]);\n", k*cnOffsetInGroup);
+
+        fprintf(fd,"        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); \n");
+            }
+
+            // Add LLR from receiver input
+        fprintf(fd,"        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);\n");
+        fprintf(fd,"        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);\n");
+
+        fprintf(fd,"        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);\n");
+        fprintf(fd,"        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);\n");
+
+            // Pack results back to epi8
+        fprintf(fd,"        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);\n");
+            // ymm0     = [ymmRes1[255:128] ymmRes0[255:128] ymmRes1[127:0] ymmRes0[127:0]]
+            // p_llrRes = [ymmRes1[255:128] ymmRes1[127:0] ymmRes0[255:128] ymmRes0[127:0]]
+        fprintf(fd,"            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);\n");
+        fprintf(fd,"             p_llrRes++;\n");
+        fprintf(fd,"}\n");
+    }
+
+
+
+    // =====================================================================
+    // Process group with 4 CNs
+
+fprintf(fd,  "// Process group with 24 CNs \n");
+
+ // Process group with 4 CNs
+
+    if (lut_numBnInBnGroups[23] > 0)
+    {
+        // If elements in group move to next address
+        idxBnGroup++;
+
+        // Number of groups of 32 BNs for parallel processing
+        M = (lut_numBnInBnGroups[23]*Z + 31)>>5;
+
+        // Set the offset to each CN within a group in terms of 16 Byte
+        cnOffsetInGroup = (lut_numBnInBnGroups[23]*NR_LDPC_ZMAX)>>4;
+
+        // Set pointers to start of group 2
+        fprintf(fd,"    p_bnProcBuf     = (__m128i*) &bnProcBuf    [%d];\n",lut_startAddrBnGroups[idxBnGroup]);
+        fprintf(fd,"    p_llrProcBuf    = (__m128i*) &llrProcBuf   [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+        fprintf(fd,"    p_llrRes        = (__m256i*) &llrRes       [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+        // Loop over BNs
+        fprintf(fd,"        for (int i=0,j=0;i<%d;i++,j+=2) {\n",M);
+            // First 16 LLRs of first CN
+        fprintf(fd,"        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);\n");
+        fprintf(fd,"        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);\n");
+
+            // Loop over CNs
+        for (k=1; k<24; k++)
+        {
+        fprintf(fd,"        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[%d + j]);\n", k*cnOffsetInGroup);
+        fprintf(fd,"        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);\n");
+
+        fprintf(fd,"        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[%d + j +1]);\n", k*cnOffsetInGroup);
+
+        fprintf(fd, "       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); \n");
+        }
+
+            // Add LLR from receiver input
+        fprintf(fd,"        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);\n");
+        fprintf(fd,"        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);\n");
+
+        fprintf(fd,"        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);\n");
+        fprintf(fd,"        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);\n");
+
+            // Pack results back to epi8
+        fprintf(fd,"        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);\n");
+            // ymm0     = [ymmRes1[255:128] ymmRes0[255:128] ymmRes1[127:0] ymmRes0[127:0]]
+            // p_llrRes = [ymmRes1[255:128] ymmRes1[127:0] ymmRes0[255:128] ymmRes0[127:0]]
+        fprintf(fd,"            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);\n");
+        fprintf(fd,"             p_llrRes++;\n");
+        fprintf(fd,"}\n");
+    }
+
+
+   // =====================================================================
+    // Process group with 5 CNs
+    
+fprintf(fd,  "// Process group with 25 CNs \n");
+
+ // Process group with 5 CNs
+
+    if (lut_numBnInBnGroups[24] > 0)
+    {
+        // If elements in group move to next address
+        idxBnGroup++;
+
+        // Number of groups of 32 BNs for parallel processing
+        M = (lut_numBnInBnGroups[24]*Z + 31)>>5;
+
+        // Set the offset to each CN within a group in terms of 16 Byte
+        cnOffsetInGroup = (lut_numBnInBnGroups[24]*NR_LDPC_ZMAX)>>4;
+
+        // Set pointers to start of group 2
+        fprintf(fd,"    p_bnProcBuf     = (__m128i*) &bnProcBuf    [%d];\n",lut_startAddrBnGroups[idxBnGroup]);
+        fprintf(fd,"    p_llrProcBuf    = (__m128i*) &llrProcBuf   [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+        fprintf(fd,"    p_llrRes        = (__m256i*) &llrRes       [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+        // Loop over BNs
+        fprintf(fd,"        for (int i=0,j=0;i<%d;i++,j+=2) {\n",M);
+            // First 16 LLRs of first CN
+        fprintf(fd,"        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);\n");
+        fprintf(fd,"        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);\n");
+
+            // Loop over CNs
+        for (k=1; k<25; k++)
+        {
+        fprintf(fd,"        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[%d + j]);\n", k*cnOffsetInGroup);
+        fprintf(fd,"        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);\n");
+
+        fprintf(fd,"        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[%d + j +1]);\n", k*cnOffsetInGroup);
+
+        fprintf(fd, "       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); \n");
+        }
+
+            // Add LLR from receiver input
+        fprintf(fd,"        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);\n");
+        fprintf(fd,"        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);\n");
+
+        fprintf(fd,"        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);\n");
+        fprintf(fd,"        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);\n");
+
+            // Pack results back to epi8
+        fprintf(fd,"        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);\n");
+            // ymm0     = [ymmRes1[255:128] ymmRes0[255:128] ymmRes1[127:0] ymmRes0[127:0]]
+            // p_llrRes = [ymmRes1[255:128] ymmRes1[127:0] ymmRes0[255:128] ymmRes0[127:0]]
+        fprintf(fd,"            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);\n");
+        fprintf(fd,"             p_llrRes++;\n");
+        fprintf(fd,"}\n");
+    }
+
+
+
+   // =====================================================================
+    // Process group with 6 CNs
+    
+fprintf(fd,  "// Process group with 26 CNs \n");
+
+ // Process group with 6 CNs
+
+    if (lut_numBnInBnGroups[25] > 0)
+    {
+        // If elements in group move to next address
+        idxBnGroup++;
+
+        // Number of groups of 32 BNs for parallel processing
+        M = (lut_numBnInBnGroups[25]*Z + 31)>>5;
+
+        // Set the offset to each CN within a group in terms of 16 Byte
+        cnOffsetInGroup = (lut_numBnInBnGroups[25]*NR_LDPC_ZMAX)>>4;
+
+        // Set pointers to start of group 2
+        fprintf(fd,"    p_bnProcBuf     = (__m128i*) &bnProcBuf    [%d];\n",lut_startAddrBnGroups[idxBnGroup]);
+        fprintf(fd,"    p_llrProcBuf    = (__m128i*) &llrProcBuf   [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+        fprintf(fd,"    p_llrRes        = (__m256i*) &llrRes       [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+        // Loop over BNs
+        fprintf(fd,"        for (int i=0,j=0;i<%d;i++,j+=2) {\n",M);
+            // First 16 LLRs of first CN
+        fprintf(fd,"        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);\n");
+        fprintf(fd,"        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);\n");
+
+            // Loop over CNs
+        for (k=1; k<26; k++)
+        {
+        fprintf(fd,"        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[%d + j]);\n", k*cnOffsetInGroup);
+        fprintf(fd,"        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);\n");
+
+        fprintf(fd,"        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[%d + j +1]);\n", k*cnOffsetInGroup);
+
+        fprintf(fd, "       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); \n");
+        }
+
+            // Add LLR from receiver input
+        fprintf(fd,"        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);\n");
+        fprintf(fd,"        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);\n");
+
+        fprintf(fd,"        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);\n");
+        fprintf(fd,"        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);\n");
+
+            // Pack results back to epi8
+        fprintf(fd,"        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);\n");
+            // ymm0     = [ymmRes1[255:128] ymmRes0[255:128] ymmRes1[127:0] ymmRes0[127:0]]
+            // p_llrRes = [ymmRes1[255:128] ymmRes1[127:0] ymmRes0[255:128] ymmRes0[127:0]]
+        fprintf(fd,"            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);\n");
+        fprintf(fd,"             p_llrRes++;\n");
+        fprintf(fd,"}\n");
+    }
+
+
+   // =====================================================================
+    // Process group with 17 CNs
+    
+fprintf(fd,  "// Process group with 27 CNs \n");
+
+ // Process group with 17 CNs
+
+    if (lut_numBnInBnGroups[26] > 0)
+    {
+        // If elements in group move to next address
+        idxBnGroup++;
+
+        // Number of groups of 32 BNs for parallel processing
+        M = (lut_numBnInBnGroups[26]*Z + 31)>>5;
+
+        // Set the offset to each CN within a group in terms of 16 Byte
+        cnOffsetInGroup = (lut_numBnInBnGroups[26]*NR_LDPC_ZMAX)>>4;
+
+        // Set pointers to start of group 2
+        fprintf(fd,"    p_bnProcBuf     = (__m128i*) &bnProcBuf    [%d];\n",lut_startAddrBnGroups[idxBnGroup]);
+        fprintf(fd,"    p_llrProcBuf    = (__m128i*) &llrProcBuf   [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+        fprintf(fd,"    p_llrRes        = (__m256i*) &llrRes       [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+        // Loop over BNs
+        fprintf(fd,"        for (int i=0,j=0;i<%d;i++,j+=2) {\n",M);
+            // First 16 LLRs of first CN
+        fprintf(fd,"        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);\n");
+        fprintf(fd,"        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);\n");
+
+            // Loop over CNs
+        for (k=1; k<27; k++)
+        {
+        fprintf(fd,"        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[%d + j]);\n", k*cnOffsetInGroup);
+        fprintf(fd,"        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);\n");
+
+        fprintf(fd,"        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[%d + j +1]);\n", k*cnOffsetInGroup);
+
+        fprintf(fd, "       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); \n");
+        }
+
+            // Add LLR from receiver input
+        fprintf(fd,"        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);\n");
+        fprintf(fd,"        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);\n");
+
+        fprintf(fd,"        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);\n");
+        fprintf(fd,"        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);\n");
+
+            // Pack results back to epi8
+        fprintf(fd,"        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);\n");
+            // ymm0     = [ymmRes1[255:128] ymmRes0[255:128] ymmRes1[127:0] ymmRes0[127:0]]
+            // p_llrRes = [ymmRes1[255:128] ymmRes1[127:0] ymmRes0[255:128] ymmRes0[127:0]]
+        fprintf(fd,"            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);\n");
+        fprintf(fd,"             p_llrRes++;\n");
+        fprintf(fd,"}\n");
+    }
+
+
+   // =====================================================================
+    // Process group with 18 CNs
+    
+fprintf(fd,  "// Process group with 28 CNs \n");
+
+ // Process group with 8 CNs
+
+    if (lut_numBnInBnGroups[27] > 0)
+    {
+        // If elements in group move to next address
+        idxBnGroup++;
+
+        // Number of groups of 32 BNs for parallel processing
+        M = (lut_numBnInBnGroups[27]*Z + 31)>>5;
+
+        // Set the offset to each CN within a group in terms of 16 Byte
+        cnOffsetInGroup = (lut_numBnInBnGroups[27]*NR_LDPC_ZMAX)>>4;
+
+        // Set pointers to start of group 2
+        fprintf(fd,"    p_bnProcBuf     = (__m128i*) &bnProcBuf    [%d];\n",lut_startAddrBnGroups[idxBnGroup]);
+        fprintf(fd,"    p_llrProcBuf    = (__m128i*) &llrProcBuf   [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+        fprintf(fd,"    p_llrRes        = (__m256i*) &llrRes       [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+        // Loop over BNs
+        fprintf(fd,"        for (int i=0,j=0;i<%d;i++,j+=2) {\n",M);
+            // First 16 LLRs of first CN
+        fprintf(fd,"        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);\n");
+        fprintf(fd,"        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);\n");
+
+            // Loop over CNs
+        for (k=1; k<28; k++)
+        {
+        fprintf(fd,"        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[%d + j]);\n", k*cnOffsetInGroup);
+        fprintf(fd,"        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);\n");
+
+        fprintf(fd,"        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[%d + j +1]);\n", k*cnOffsetInGroup);
+
+        fprintf(fd, "       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); \n");
+        }
+
+            // Add LLR from receiver input
+        fprintf(fd,"        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);\n");
+        fprintf(fd,"        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);\n");
+
+        fprintf(fd,"        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);\n");
+        fprintf(fd,"        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);\n");
+
+            // Pack results back to epi8
+        fprintf(fd,"        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);\n");
+            // ymm0     = [ymmRes1[255:128] ymmRes0[255:128] ymmRes1[127:0] ymmRes0[127:0]]
+            // p_llrRes = [ymmRes1[255:128] ymmRes1[127:0] ymmRes0[255:128] ymmRes0[127:0]]
+        fprintf(fd,"            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);\n");
+        fprintf(fd,"             p_llrRes++;\n");
+        fprintf(fd,"}\n");
+    }
+
+   // =====================================================================
+    // Process group with 9 CNs
+    
+fprintf(fd,  "// Process group with 29 CNs \n");
+
+ // Process group with 9 CNs
+
+    if (lut_numBnInBnGroups[28] > 0)
+    {
+        // If elements in group move to next address
+        idxBnGroup++;
+
+        // Number of groups of 32 BNs for parallel processing
+        M = (lut_numBnInBnGroups[28]*Z + 31)>>5;
+
+        // Set the offset to each CN within a group in terms of 16 Byte
+        cnOffsetInGroup = (lut_numBnInBnGroups[28]*NR_LDPC_ZMAX)>>4;
+
+        // Set pointers to start of group 2
+        fprintf(fd,"    p_bnProcBuf     = (__m128i*) &bnProcBuf    [%d];\n",lut_startAddrBnGroups[idxBnGroup]);
+        fprintf(fd,"    p_llrProcBuf    = (__m128i*) &llrProcBuf   [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+        fprintf(fd,"    p_llrRes        = (__m256i*) &llrRes       [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+        // Loop over BNs
+        fprintf(fd,"        for (int i=0,j=0;i<%d;i++,j+=2) {\n",M);
+            // First 16 LLRs of first CN
+        fprintf(fd,"        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);\n");
+        fprintf(fd,"        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);\n");
+
+            // Loop over CNs
+        for (k=1; k<29; k++)
+        {
+        fprintf(fd,"        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[%d + j]);\n", k*cnOffsetInGroup);
+        fprintf(fd,"        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);\n");
+
+        fprintf(fd,"        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[%d + j +1]);\n", k*cnOffsetInGroup);
+
+        fprintf(fd, "       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); \n");
+        }
+
+            // Add LLR from receiver input
+        fprintf(fd,"        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);\n");
+        fprintf(fd,"        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);\n");
+
+        fprintf(fd,"        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);\n");
+        fprintf(fd,"        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);\n");
+
+            // Pack results back to epi8
+        fprintf(fd,"        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);\n");
+            // ymm0     = [ymmRes1[255:128] ymmRes0[255:128] ymmRes1[127:0] ymmRes0[127:0]]
+            // p_llrRes = [ymmRes1[255:128] ymmRes1[127:0] ymmRes0[255:128] ymmRes0[127:0]]
+        fprintf(fd,"            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);\n");
+        fprintf(fd,"             p_llrRes++;\n");
+        fprintf(fd,"}\n");
+    }
+
+
+   // =====================================================================
+    // Process group with 20 CNs
+    
+fprintf(fd,  "// Process group with 30 CNs \n");
+
+ // Process group with 20 CNs
+
+    if (lut_numBnInBnGroups[29] > 0)
+    {
+        // If elements in group move to next address
+        idxBnGroup++;
+
+        // Number of groups of 32 BNs for parallel processing
+        M = (lut_numBnInBnGroups[29]*Z + 31)>>5;
+
+        // Set the offset to each CN within a group in terms of 16 Byte
+        cnOffsetInGroup = (lut_numBnInBnGroups[29]*NR_LDPC_ZMAX)>>4;
+
+        // Set pointers to start of group 2
+        fprintf(fd,"    p_bnProcBuf     = (__m128i*) &bnProcBuf    [%d];\n",lut_startAddrBnGroups[idxBnGroup]);
+        fprintf(fd,"    p_llrProcBuf    = (__m128i*) &llrProcBuf   [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+        fprintf(fd,"    p_llrRes        = (__m256i*) &llrRes       [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+        // Loop over BNs
+        fprintf(fd,"        for (int i=0,j=0;i<%d;i++,j+=2) {\n",M);
+            // First 16 LLRs of first CN
+        fprintf(fd,"        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);\n");
+        fprintf(fd,"        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);\n");
+
+            // Loop over CNs
+        for (k=1; k<30; k++)
+        {
+        fprintf(fd,"        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[%d + j]);\n", k*cnOffsetInGroup);
+        fprintf(fd,"        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);\n");
+
+        fprintf(fd,"        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[%d + j +1]);\n", k*cnOffsetInGroup);
+
+        fprintf(fd, "       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); \n");
+        }
+
+            // Add LLR from receiver input
+        fprintf(fd,"        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);\n");
+        fprintf(fd,"        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);\n");
+
+        fprintf(fd,"        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);\n");
+        fprintf(fd,"        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);\n");
+
+            // Pack results back to epi8
+        fprintf(fd,"        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);\n");
+            // ymm0     = [ymmRes1[255:128] ymmRes0[255:128] ymmRes1[127:0] ymmRes0[127:0]]
+            // p_llrRes = [ymmRes1[255:128] ymmRes1[127:0] ymmRes0[255:128] ymmRes0[127:0]]
+        fprintf(fd,"            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);\n");
+        fprintf(fd,"             p_llrRes++;\n");
+        fprintf(fd,"}\n");
+    }
+
+    fprintf(fd,"}\n");
+  fclose(fd);
+}//end of the function  nrLDPC_bnProc_BG1
+
+
+
+
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_bnProc/bnProcPc_gen_BG2_avx2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_bnProc/bnProcPc_gen_BG2_avx2.c
new file mode 100644
index 0000000000..68783ae0da
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_bnProc/bnProcPc_gen_BG2_avx2.c
@@ -0,0 +1,1773 @@
+
+
+#include <stdint.h>
+#include <immintrin.h>
+#include "../../nrLDPCdecoder_defs.h"
+#include "../../nrLDPC_types.h"
+#include "../../nrLDPC_bnProc.h"
+#include "../../nrLDPC_cnProc.h"
+#include "../../nrLDPC_init.h"
+
+void nrLDPC_bnProcPc_BG2_generator_AVX2(uint16_t Z,int R)
+{
+  const char *ratestr[3]={"15","13","23"};
+
+  if (R<0 || R>2) {printf("Illegal R %d\n",R); abort();}
+
+
+ // system("mkdir -p ../ldpc_gen_files");
+
+  char fname[50];
+  sprintf(fname,"../ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z%d_R%s_AVX2.c",Z,ratestr[R]);
+  FILE *fd=fopen(fname,"w");
+  if (fd == NULL) {printf("Cannot create \n");abort();}
+
+  fprintf(fd,"#include <stdint.h>\n");
+  fprintf(fd,"#include <immintrin.h>\n");
+
+  //fprintf(fd,"void nrLDPC_bnProc_BG1_Z%d_%s_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes,  int8_t* llrRes ,  int8_t* llrProcBuf ) {\n",Z,ratestr[R]);
+    
+  fprintf(fd,"void nrLDPC_bnProcPc_BG2_Z%d_R%s_AVX2(int8_t* bnProcBuf, int8_t* bnProcBufRes,  int8_t* llrRes ,  int8_t* llrProcBuf ) {\n",Z,ratestr[R]);
+    const uint8_t*  lut_numBnInBnGroups;
+    const uint32_t* lut_startAddrBnGroups;
+    const uint16_t* lut_startAddrBnGroupsLlr;
+    //BG1
+  if (R==0) {
+      lut_numBnInBnGroups = lut_numBnInBnGroups_BG2_R15;
+      lut_startAddrBnGroups = lut_startAddrBnGroups_BG2_R15;
+      lut_startAddrBnGroupsLlr = lut_startAddrBnGroupsLlr_BG2_R15;
+    }
+    else if (R==1) {
+      lut_numBnInBnGroups = lut_numBnInBnGroups_BG2_R13;
+      lut_startAddrBnGroups = lut_startAddrBnGroups_BG2_R13;
+      lut_startAddrBnGroupsLlr = lut_startAddrBnGroupsLlr_BG2_R13;
+    }
+    else if (R==2) {
+      lut_numBnInBnGroups = lut_numBnInBnGroups_BG2_R23;
+      lut_startAddrBnGroups = lut_startAddrBnGroups_BG2_R23;
+      lut_startAddrBnGroupsLlr = lut_startAddrBnGroupsLlr_BG2_R23;
+    }
+
+
+  else { printf("aborting, illegal R %d\n",R); fclose(fd);abort();}
+
+        // Number of BNs in Groups
+    uint32_t M;
+    //uint32_t M32rem;
+   // uint32_t i,j;
+    uint32_t k;
+    // Offset to each bit within a group in terms of 32 Byte
+    uint32_t cnOffsetInGroup;
+    uint8_t idxBnGroup = 0;
+
+    fprintf(fd,"   __m256i ymm0, ymm1, ymmRes0, ymmRes1;  \n");
+
+    
+    fprintf(fd,"        __m128i* p_bnProcBuf; \n");
+    fprintf(fd,"        __m256i* p_bnProcBufRes; \n");
+    fprintf(fd,"        __m128i* p_llrProcBuf;\n");
+    fprintf(fd,"        __m256i* p_llrProcBuf256; \n");
+    fprintf(fd,"        __m256i* p_llrRes; \n");
+
+
+
+   
+
+
+    // =====================================================================
+    // Process group with 1 CN
+    // Already done in bnProcBufPc
+
+    // =====================================================================
+   
+fprintf(fd,  "// Process group with 1 CNs \n");
+
+   // if (lut_numBnInBnGroups[1] > 0)
+  //  {
+        // If elements in group move to next address
+//        idxBnGroup++;
+
+        // Number of groups of 32 BNs for parallel processing
+        M = (lut_numBnInBnGroups[0]*Z + 31)>>5;
+
+    fprintf(fd,"    p_bnProcBuf     = (__m128i*) &bnProcBuf    [%d];\n",lut_startAddrBnGroups[idxBnGroup]);
+    fprintf(fd,"    p_bnProcBufRes  = (__m256i*) &bnProcBufRes [%d];\n",lut_startAddrBnGroups[idxBnGroup]);
+    fprintf(fd,"    p_llrProcBuf    = (__m128i*) &llrProcBuf   [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+    fprintf(fd,"    p_llrProcBuf256 = (__m256i*) &llrProcBuf   [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+    fprintf(fd,"    p_llrRes        = (__m256i*) &llrRes       [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+
+
+        fprintf(fd,"            for (int i=0,j=0;i<%d;i++,j+=2) {\n",M);
+
+           //for (i=0,j=0;i<M;i++,j+=2) {
+
+            // Store results in bnProcBufRes of first CN for further processing for next iteration
+            // In case parity check fails
+
+
+        fprintf(fd,"             p_bnProcBufRes[i] = p_llrProcBuf256[i];\n");
+
+            // First 16 LLRs of first CN
+        fprintf(fd,"            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);\n");
+        fprintf(fd,"            ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);\n");
+        fprintf(fd,"            ymmRes0 = _mm256_adds_epi16(ymm0, ymm1);\n");
+
+            // Second 16 LLRs of first CN
+        fprintf(fd,"            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j+1]);\n");
+        fprintf(fd,"           ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j+1]);\n");
+        fprintf(fd,"            ymmRes1 = _mm256_adds_epi16(ymm0, ymm1);\n");
+
+            // Pack results back to epi8
+        fprintf(fd,"            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);\n");
+            // ymm0     = [ymmRes1[255:128] ymmRes0[255:128] ymmRes1[127:0] ymmRes0[127:0]]
+            // p_llrRes = [ymmRes1[255:128] ymmRes1[127:0] ymmRes0[255:128] ymmRes0[127:0]]
+        fprintf(fd,"            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);\n");
+        fprintf(fd,"             p_llrRes++;\n");
+
+ //}
+  fprintf(fd,"}\n");
+
+      // =====================================================================
+    // Process group with 2 CNs
+
+
+fprintf(fd,  "// Process group with 2 CNs \n");
+
+ // Process group with 2 CNs
+
+    if (lut_numBnInBnGroups[1] > 0)
+    {
+        // If elements in group move to next address
+        idxBnGroup++;
+
+        // Number of groups of 32 BNs for parallel processing
+        M = (lut_numBnInBnGroups[1]*Z + 31)>>5;
+
+        // Set the offset to each CN within a group in terms of 16 Byte
+        cnOffsetInGroup = (lut_numBnInBnGroups[1]*NR_LDPC_ZMAX)>>4;
+
+        // Set pointers to start of group 2
+        fprintf(fd,"    p_bnProcBuf     = (__m128i*) &bnProcBuf    [%d];\n",lut_startAddrBnGroups[idxBnGroup]);
+        fprintf(fd,"    p_llrProcBuf    = (__m128i*) &llrProcBuf   [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+        fprintf(fd,"    p_llrRes        = (__m256i*) &llrRes       [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+
+        // Loop over BNs
+        fprintf(fd,"            for (int i=0,j=0;i<%d;i++,j+=2) {\n",M);
+            // First 16 LLRs of first CN
+        fprintf(fd,"            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);\n");
+        fprintf(fd,"            ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);\n");
+
+            // Loop over CNs
+        for (k=1; k<2; k++)
+        {
+        fprintf(fd,"            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[%d + j]);\n", k*cnOffsetInGroup);
+        fprintf(fd,"            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);\n");
+
+        fprintf(fd,"            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[%d + j +1]);\n", k*cnOffsetInGroup);
+
+        fprintf(fd, "           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); \n");
+        }
+
+            // Add LLR from receiver input
+        fprintf(fd,"            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);\n");
+        fprintf(fd,"            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);\n");
+
+        fprintf(fd,"            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);\n");
+        fprintf(fd,"            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);\n");
+
+            // Pack results back to epi8
+        fprintf(fd,"            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);\n");
+            // ymm0     = [ymmRes1[255:128] ymmRes0[255:128] ymmRes1[127:0] ymmRes0[127:0]]
+            // p_llrRes = [ymmRes1[255:128] ymmRes1[127:0] ymmRes0[255:128] ymmRes0[127:0]]
+        fprintf(fd,"            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);\n");
+        fprintf(fd,"             p_llrRes++;\n");
+
+        fprintf(fd,"}\n");
+    }
+
+    // =====================================================================
+    // Process group with 3 CNs
+
+
+fprintf(fd,  "// Process group with 3 CNs \n");
+
+ // Process group with 3 CNs
+
+    if (lut_numBnInBnGroups[2] > 0)
+    {
+        // If elements in group move to next address
+        idxBnGroup++;
+
+        // Number of groups of 32 BNs for parallel processing
+        M = (lut_numBnInBnGroups[2]*Z + 31)>>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 2
+        fprintf(fd,"    p_bnProcBuf     = (__m128i*) &bnProcBuf    [%d];\n",lut_startAddrBnGroups[idxBnGroup]);
+        fprintf(fd,"    p_llrProcBuf    = (__m128i*) &llrProcBuf   [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+        fprintf(fd,"    p_llrRes        = (__m256i*) &llrRes       [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+        // Loop over BNs
+        fprintf(fd,"        for (int i=0,j=0;i<%d;i++,j+=2) {\n",M);
+            // First 16 LLRs of first CN
+        fprintf(fd,"        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);\n");
+        fprintf(fd,"        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);\n");
+
+            // Loop over CNs
+        for (k=1; k<3; k++)
+        {
+        fprintf(fd,"        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[%d + j]);\n", k*cnOffsetInGroup);
+        fprintf(fd,"        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);\n");
+
+        fprintf(fd,"        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[%d + j +1]);\n", k*cnOffsetInGroup);
+
+        fprintf(fd,"        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); \n");
+            }
+
+            // Add LLR from receiver input
+        fprintf(fd,"        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);\n");
+        fprintf(fd,"        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);\n");
+
+        fprintf(fd,"        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);\n");
+        fprintf(fd,"        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);\n");
+
+            // Pack results back to epi8
+        fprintf(fd,"        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);\n");
+            // ymm0     = [ymmRes1[255:128] ymmRes0[255:128] ymmRes1[127:0] ymmRes0[127:0]]
+        fprintf(fd,"            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);\n");
+        fprintf(fd,"             p_llrRes++;\n");
+        fprintf(fd,"}\n");
+    }
+
+
+
+    // =====================================================================
+    // Process group with 4 CNs
+
+fprintf(fd,  "// Process group with 4 CNs \n");
+
+ // Process group with 4 CNs
+
+    if (lut_numBnInBnGroups[3] > 0)
+    {
+        // If elements in group move to next address
+        idxBnGroup++;
+
+        // Number of groups of 32 BNs for parallel processing
+        M = (lut_numBnInBnGroups[3]*Z + 31)>>5;
+
+        // Set the offset to each CN within a group in terms of 16 Byte
+        cnOffsetInGroup = (lut_numBnInBnGroups[3]*NR_LDPC_ZMAX)>>4;
+
+        // Set pointers to start of group 2
+        fprintf(fd,"    p_bnProcBuf     = (__m128i*) &bnProcBuf    [%d];\n",lut_startAddrBnGroups[idxBnGroup]);
+        fprintf(fd,"    p_llrProcBuf    = (__m128i*) &llrProcBuf   [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+        fprintf(fd,"    p_llrRes        = (__m256i*) &llrRes       [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+
+        // Loop over BNs
+        fprintf(fd,"        for (int i=0,j=0;i<%d;i++,j+=2) {\n",M);
+            // First 16 LLRs of first CN
+        fprintf(fd,"        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);\n");
+        fprintf(fd,"        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);\n");
+
+            // Loop over CNs
+        for (k=1; k<4; k++)
+        {
+        fprintf(fd,"        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[%d + j]);\n", k*cnOffsetInGroup);
+        fprintf(fd,"        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);\n");
+
+        fprintf(fd,"        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[%d + j +1]);\n", k*cnOffsetInGroup);
+
+        fprintf(fd, "       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); \n");
+        }
+
+            // Add LLR from receiver input
+        fprintf(fd,"        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);\n");
+        fprintf(fd,"        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);\n");
+
+        fprintf(fd,"        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);\n");
+        fprintf(fd,"        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);\n");
+
+            // Pack results back to epi8
+        fprintf(fd,"        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);\n");
+            // ymm0     = [ymmRes1[255:128] ymmRes0[255:128] ymmRes1[127:0] ymmRes0[127:0]]
+            // p_llrRes = [ymmRes1[255:128] ymmRes1[127:0] ymmRes0[255:128] ymmRes0[127:0]]
+        fprintf(fd,"            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);\n");
+        fprintf(fd,"             p_llrRes++;\n");
+        fprintf(fd,"}\n");
+    }
+
+
+   // =====================================================================
+    // Process group with 5 CNs
+    
+fprintf(fd,  "// Process group with 5 CNs \n");
+
+ // Process group with 5 CNs
+
+    if (lut_numBnInBnGroups[4] > 0)
+    {
+        // If elements in group move to next address
+        idxBnGroup++;
+
+        // Number of groups of 32 BNs for parallel processing
+        M = (lut_numBnInBnGroups[4]*Z + 31)>>5;
+
+        // Set the offset to each CN within a group in terms of 16 Byte
+        cnOffsetInGroup = (lut_numBnInBnGroups[4]*NR_LDPC_ZMAX)>>4;
+
+        // Set pointers to start of group 2
+        fprintf(fd,"    p_bnProcBuf     = (__m128i*) &bnProcBuf    [%d];\n",lut_startAddrBnGroups[idxBnGroup]);
+        fprintf(fd,"    p_llrProcBuf    = (__m128i*) &llrProcBuf   [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+        fprintf(fd,"    p_llrRes        = (__m256i*) &llrRes       [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+        // Loop over BNs
+        fprintf(fd,"        for (int i=0,j=0;i<%d;i++,j+=2) {\n",M);
+            // First 16 LLRs of first CN
+        fprintf(fd,"        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);\n");
+        fprintf(fd,"        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);\n");
+
+            // Loop over CNs
+        for (k=1; k<5; k++)
+        {
+        fprintf(fd,"        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[%d + j]);\n", k*cnOffsetInGroup);
+        fprintf(fd,"        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);\n");
+
+        fprintf(fd,"        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[%d + j +1]);\n", k*cnOffsetInGroup);
+
+        fprintf(fd, "       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); \n");
+        }
+
+            // Add LLR from receiver input
+        fprintf(fd,"        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);\n");
+        fprintf(fd,"        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);\n");
+
+        fprintf(fd,"        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);\n");
+        fprintf(fd,"        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);\n");
+
+            // Pack results back to epi8
+        fprintf(fd,"        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);\n");
+            // ymm0     = [ymmRes1[255:128] ymmRes0[255:128] ymmRes1[127:0] ymmRes0[127:0]]
+            // p_llrRes = [ymmRes1[255:128] ymmRes1[127:0] ymmRes0[255:128] ymmRes0[127:0]]
+        fprintf(fd,"            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);\n");
+        fprintf(fd,"             p_llrRes++;\n");
+        fprintf(fd,"}\n");
+    }
+
+
+
+   // =====================================================================
+    // Process group with 6 CNs
+    
+fprintf(fd,  "// Process group with 6 CNs \n");
+
+ // Process group with 6 CNs
+
+    if (lut_numBnInBnGroups[5] > 0)
+    {
+        // If elements in group move to next address
+        idxBnGroup++;
+
+        // Number of groups of 32 BNs for parallel processing
+        M = (lut_numBnInBnGroups[5]*Z + 31)>>5;
+
+        // Set the offset to each CN within a group in terms of 16 Byte
+        cnOffsetInGroup = (lut_numBnInBnGroups[5]*NR_LDPC_ZMAX)>>4;
+
+        // Set pointers to start of group 2
+        fprintf(fd,"    p_bnProcBuf     = (__m128i*) &bnProcBuf    [%d];\n",lut_startAddrBnGroups[idxBnGroup]);
+        fprintf(fd,"    p_llrProcBuf    = (__m128i*) &llrProcBuf   [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+        fprintf(fd,"    p_llrRes        = (__m256i*) &llrRes       [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+        // Loop over BNs
+        fprintf(fd,"        for (int i=0,j=0;i<%d;i++,j+=2) {\n",M);
+            // First 16 LLRs of first CN
+        fprintf(fd,"        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);\n");
+        fprintf(fd,"        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);\n");
+
+            // Loop over CNs
+        for (k=1; k<6; k++)
+        {
+        fprintf(fd,"        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[%d + j]);\n", k*cnOffsetInGroup);
+        fprintf(fd,"        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);\n");
+
+        fprintf(fd,"        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[%d + j +1]);\n", k*cnOffsetInGroup);
+
+        fprintf(fd, "       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); \n");
+        }
+
+            // Add LLR from receiver input
+        fprintf(fd,"        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);\n");
+        fprintf(fd,"        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);\n");
+
+        fprintf(fd,"        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);\n");
+        fprintf(fd,"        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);\n");
+
+            // Pack results back to epi8
+        fprintf(fd,"        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);\n");
+            // ymm0     = [ymmRes1[255:128] ymmRes0[255:128] ymmRes1[127:0] ymmRes0[127:0]]
+            // p_llrRes = [ymmRes1[255:128] ymmRes1[127:0] ymmRes0[255:128] ymmRes0[127:0]]
+        fprintf(fd,"            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);\n");
+        fprintf(fd,"             p_llrRes++;\n");
+        fprintf(fd,"}\n");
+    }
+
+
+   // =====================================================================
+    // Process group with 7 CNs
+    
+fprintf(fd,  "// Process group with 7 CNs \n");
+
+ // Process group with 7 CNs
+
+    if (lut_numBnInBnGroups[6] > 0)
+    {
+        // If elements in group move to next address
+        idxBnGroup++;
+
+        // Number of groups of 32 BNs for parallel processing
+        M = (lut_numBnInBnGroups[6]*Z + 31)>>5;
+
+        // Set the offset to each CN within a group in terms of 16 Byte
+        cnOffsetInGroup = (lut_numBnInBnGroups[6]*NR_LDPC_ZMAX)>>4;
+
+        // Set pointers to start of group 2
+        fprintf(fd,"    p_bnProcBuf     = (__m128i*) &bnProcBuf    [%d];\n",lut_startAddrBnGroups[idxBnGroup]);
+        fprintf(fd,"    p_llrProcBuf    = (__m128i*) &llrProcBuf   [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+        fprintf(fd,"    p_llrRes        = (__m256i*) &llrRes       [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+        // Loop over BNs
+        fprintf(fd,"        for (int i=0,j=0;i<%d;i++,j+=2) {\n",M);
+            // First 16 LLRs of first CN
+        fprintf(fd,"        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);\n");
+        fprintf(fd,"        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);\n");
+
+            // Loop over CNs
+        for (k=1; k<7; k++)
+        {
+        fprintf(fd,"        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[%d + j]);\n", k*cnOffsetInGroup);
+        fprintf(fd,"        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);\n");
+
+        fprintf(fd,"        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[%d + j +1]);\n", k*cnOffsetInGroup);
+
+        fprintf(fd, "       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); \n");
+        }
+
+            // Add LLR from receiver input
+        fprintf(fd,"        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);\n");
+        fprintf(fd,"        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);\n");
+
+        fprintf(fd,"        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);\n");
+        fprintf(fd,"        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);\n");
+
+            // Pack results back to epi8
+        fprintf(fd,"        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);\n");
+            // ymm0     = [ymmRes1[255:128] ymmRes0[255:128] ymmRes1[127:0] ymmRes0[127:0]]
+            // p_llrRes = [ymmRes1[255:128] ymmRes1[127:0] ymmRes0[255:128] ymmRes0[127:0]]
+        //fprintf(fd,"         (__m256i*) &llrRes[%d + i]    = _mm256_permute4x64_epi64(ymm0, 0xD8);\n",lut_startAddrBnGroupsLlr[idxBnGroup]>>5 );
+        fprintf(fd,"            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);\n");
+        fprintf(fd,"             p_llrRes++;\n");
+        fprintf(fd,"}\n");
+    }
+
+
+   // =====================================================================
+    // Process group with 8 CNs
+    
+fprintf(fd,  "// Process group with 8 CNs \n");
+
+ // Process group with 8 CNs
+
+    if (lut_numBnInBnGroups[7] > 0)
+    {
+        // If elements in group move to next address
+        idxBnGroup++;
+
+        // Number of groups of 32 BNs for parallel processing
+        M = (lut_numBnInBnGroups[7]*Z + 31)>>5;
+
+        // Set the offset to each CN within a group in terms of 16 Byte
+        cnOffsetInGroup = (lut_numBnInBnGroups[7]*NR_LDPC_ZMAX)>>4;
+
+        // Set pointers to start of group 2
+        fprintf(fd,"    p_bnProcBuf     = (__m128i*) &bnProcBuf    [%d];\n",lut_startAddrBnGroups[idxBnGroup]);
+        fprintf(fd,"    p_llrProcBuf    = (__m128i*) &llrProcBuf   [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+        fprintf(fd,"    p_llrRes        = (__m256i*) &llrRes       [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+        // Loop over BNs
+        fprintf(fd,"        for (int i=0,j=0;i<%d;i++,j+=2) {\n",M);
+            // First 16 LLRs of first CN
+        fprintf(fd,"        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);\n");
+        fprintf(fd,"        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);\n");
+
+            // Loop over CNs
+        for (k=1; k<8; k++)
+        {
+        fprintf(fd,"        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[%d + j]);\n", k*cnOffsetInGroup);
+        fprintf(fd,"        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);\n");
+
+        fprintf(fd,"        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[%d + j +1]);\n", k*cnOffsetInGroup);
+
+        fprintf(fd, "       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); \n");
+        }
+
+            // Add LLR from receiver input
+        fprintf(fd,"        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);\n");
+        fprintf(fd,"        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);\n");
+
+        fprintf(fd,"        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);\n");
+        fprintf(fd,"        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);\n");
+
+            // Pack results back to epi8
+        fprintf(fd,"        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);\n");
+            // ymm0     = [ymmRes1[255:128] ymmRes0[255:128] ymmRes1[127:0] ymmRes0[127:0]]
+            // p_llrRes = [ymmRes1[255:128] ymmRes1[127:0] ymmRes0[255:128] ymmRes0[127:0]]
+        //fprintf(fd,"         (__m256i*) &llrRes[%d + i]    = _mm256_permute4x64_epi64(ymm0, 0xD8);\n",lut_startAddrBnGroupsLlr[idxBnGroup]>>5 );
+
+        fprintf(fd,"            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);\n");
+        fprintf(fd,"             p_llrRes++;\n");
+        fprintf(fd,"}\n");
+    }
+
+   // =====================================================================
+    // Process group with 9 CNs
+    
+fprintf(fd,  "// Process group with 9 CNs \n");
+
+ // Process group with 9 CNs
+
+    if (lut_numBnInBnGroups[8] > 0)
+    {
+        // If elements in group move to next address
+        idxBnGroup++;
+
+        // Number of groups of 32 BNs for parallel processing
+        M = (lut_numBnInBnGroups[8]*Z + 31)>>5;
+
+        // Set the offset to each CN within a group in terms of 16 Byte
+        cnOffsetInGroup = (lut_numBnInBnGroups[8]*NR_LDPC_ZMAX)>>4;
+
+        // Set pointers to start of group 2
+        fprintf(fd,"    p_bnProcBuf     = (__m128i*) &bnProcBuf    [%d];\n",lut_startAddrBnGroups[idxBnGroup]);
+        fprintf(fd,"    p_llrProcBuf    = (__m128i*) &llrProcBuf   [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+        fprintf(fd,"    p_llrRes        = (__m256i*) &llrRes       [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+        // Loop over BNs
+        fprintf(fd,"        for (int i=0,j=0;i<%d;i++,j+=2) {\n",M);
+            // First 16 LLRs of first CN
+        fprintf(fd,"        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);\n");
+        fprintf(fd,"        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);\n");
+
+            // Loop over CNs
+        for (k=1; k<9; k++)
+        {
+        fprintf(fd,"        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[%d + j]);\n", k*cnOffsetInGroup);
+        fprintf(fd,"        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);\n");
+
+        fprintf(fd,"        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[%d + j +1]);\n", k*cnOffsetInGroup);
+
+        fprintf(fd, "       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); \n");
+        }
+
+            // Add LLR from receiver input
+        fprintf(fd,"        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);\n");
+        fprintf(fd,"        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);\n");
+
+        fprintf(fd,"        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);\n");
+        fprintf(fd,"        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);\n");
+
+            // Pack results back to epi8
+        fprintf(fd,"        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);\n");
+            // ymm0     = [ymmRes1[255:128] ymmRes0[255:128] ymmRes1[127:0] ymmRes0[127:0]]
+            // p_llrRes = [ymmRes1[255:128] ymmRes1[127:0] ymmRes0[255:128] ymmRes0[127:0]]
+        //fprintf(fd,"         (__m256i*) &llrRes[%d + i]    = _mm256_permute4x64_epi64(ymm0, 0xD8);\n",lut_startAddrBnGroupsLlr[idxBnGroup]>>5 );
+        fprintf(fd,"            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);\n");
+        fprintf(fd,"             p_llrRes++;\n");
+        fprintf(fd,"}\n");
+    }
+
+
+   // =====================================================================
+    // Process group with 10 CNs
+    
+fprintf(fd,  "// Process group with 10 CNs \n");
+
+ // Process group with 10 CNs
+
+    if (lut_numBnInBnGroups[9] > 0)
+    {
+        // If elements in group move to next address
+        idxBnGroup++;
+
+        // Number of groups of 32 BNs for parallel processing
+        M = (lut_numBnInBnGroups[9]*Z + 31)>>5;
+
+        // Set the offset to each CN within a group in terms of 16 Byte
+        cnOffsetInGroup = (lut_numBnInBnGroups[9]*NR_LDPC_ZMAX)>>4;
+
+        // Set pointers to start of group 2
+        fprintf(fd,"    p_bnProcBuf     = (__m128i*) &bnProcBuf    [%d];\n",lut_startAddrBnGroups[idxBnGroup]);
+        fprintf(fd,"    p_llrProcBuf    = (__m128i*) &llrProcBuf   [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+        fprintf(fd,"    p_llrRes        = (__m256i*) &llrRes       [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+        // Loop over BNs
+        fprintf(fd,"        for (int i=0,j=0;i<%d;i++,j+=2) {\n",M);
+            // First 16 LLRs of first CN
+        fprintf(fd,"        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);\n");
+        fprintf(fd,"        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);\n");
+
+            // Loop over CNs
+        for (k=1; k<10; k++)
+        {
+        fprintf(fd,"        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[%d + j]);\n", k*cnOffsetInGroup);
+        fprintf(fd,"        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);\n");
+
+        fprintf(fd,"        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[%d + j +1]);\n", k*cnOffsetInGroup);
+
+        fprintf(fd, "       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); \n");
+        }
+
+            // Add LLR from receiver input
+        fprintf(fd,"        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);\n");
+        fprintf(fd,"        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);\n");
+
+        fprintf(fd,"        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);\n");
+        fprintf(fd,"        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);\n");
+
+            // Pack results back to epi8
+        fprintf(fd,"        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);\n");
+            // ymm0     = [ymmRes1[255:128] ymmRes0[255:128] ymmRes1[127:0] ymmRes0[127:0]]
+            // p_llrRes = [ymmRes1[255:128] ymmRes1[127:0] ymmRes0[255:128] ymmRes0[127:0]]
+        fprintf(fd,"            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);\n");
+        fprintf(fd,"             p_llrRes++;\n");
+        fprintf(fd,"}\n");
+    }
+
+
+
+    // =====================================================================
+   
+fprintf(fd,  "// Process group with 11 CNs \n");
+
+
+
+ // Process group with 2 CNs
+
+    if (lut_numBnInBnGroups[10] > 0)
+    {
+        // If elements in group move to next address
+        idxBnGroup++;
+
+        // Number of groups of 32 BNs for parallel processing
+        M = (lut_numBnInBnGroups[10]*Z + 31)>>5;
+
+        // Set the offset to each CN within a group in terms of 16 Byte
+        cnOffsetInGroup = (lut_numBnInBnGroups[10]*NR_LDPC_ZMAX)>>4;
+
+        // Set pointers to start of group 2
+        fprintf(fd,"    p_bnProcBuf     = (__m128i*) &bnProcBuf    [%d];\n",lut_startAddrBnGroups[idxBnGroup]);
+        fprintf(fd,"    p_llrProcBuf    = (__m128i*) &llrProcBuf   [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+        fprintf(fd,"    p_llrRes        = (__m256i*) &llrRes       [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+        // Loop over BNs
+        fprintf(fd,"            for (int i=0,j=0;i<%d;i++,j+=2) {\n",M);
+            // First 16 LLRs of first CN
+        fprintf(fd,"            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);\n");
+        fprintf(fd,"            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);\n");
+
+            // Loop over CNs
+        for (k=1; k<11; k++)
+        {
+        fprintf(fd,"            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[%d + j]);\n", k*cnOffsetInGroup);
+        fprintf(fd,"            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);\n");
+
+        fprintf(fd,"            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[%d + j +1]);\n", k*cnOffsetInGroup);
+
+        fprintf(fd, "           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); \n");
+        }
+
+            // Add LLR from receiver input
+        fprintf(fd,"            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);\n");
+        fprintf(fd,"            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);\n");
+
+        fprintf(fd,"            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);\n");
+        fprintf(fd,"            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);\n");
+
+            // Pack results back to epi8
+        fprintf(fd,"            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);\n");
+            // ymm0     = [ymmRes1[255:128] ymmRes0[255:128] ymmRes1[127:0] ymmRes0[127:0]]
+            // p_llrRes = [ymmRes1[255:128] ymmRes1[127:0] ymmRes0[255:128] ymmRes0[127:0]]
+        fprintf(fd,"            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);\n");
+        fprintf(fd,"             p_llrRes++;\n");
+        fprintf(fd,"}\n");
+    }
+      // =====================================================================
+    // Process group with 2 CNs
+
+
+fprintf(fd,  "// Process group with 12 CNs \n");
+
+ // Process group with 2 CNs
+
+    if (lut_numBnInBnGroups[11] > 0)
+    {
+        // If elements in group move to next address
+        idxBnGroup++;
+
+        // Number of groups of 32 BNs for parallel processing
+        M = (lut_numBnInBnGroups[11]*Z + 31)>>5;
+
+        // Set the offset to each CN within a group in terms of 16 Byte
+        cnOffsetInGroup = (lut_numBnInBnGroups[11]*NR_LDPC_ZMAX)>>4;
+
+        // Set pointers to start of group 2
+        fprintf(fd,"    p_bnProcBuf     = (__m128i*) &bnProcBuf    [%d];\n",lut_startAddrBnGroups[idxBnGroup]);
+        fprintf(fd,"    p_llrProcBuf    = (__m128i*) &llrProcBuf   [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+        fprintf(fd,"    p_llrRes        = (__m256i*) &llrRes       [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+        // Loop over BNs
+        fprintf(fd,"            for (int i=0,j=0;i<%d;i++,j+=2) {\n",M);
+            // First 16 LLRs of first CN
+        fprintf(fd,"            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);\n");
+        fprintf(fd,"            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);\n");
+
+            // Loop over CNs
+        for (k=1; k<12; k++)
+        {
+        fprintf(fd,"            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[%d + j]);\n", k*cnOffsetInGroup);
+        fprintf(fd,"            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);\n");
+
+        fprintf(fd,"            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[%d + j +1]);\n", k*cnOffsetInGroup);
+
+        fprintf(fd, "           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); \n");
+        }
+
+            // Add LLR from receiver input
+        fprintf(fd,"            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);\n");
+        fprintf(fd,"            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);\n");
+
+        fprintf(fd,"            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);\n");
+        fprintf(fd,"            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);\n");
+
+            // Pack results back to epi8
+        fprintf(fd,"            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);\n");
+            // ymm0     = [ymmRes1[255:128] ymmRes0[255:128] ymmRes1[127:0] ymmRes0[127:0]]
+            // p_llrRes = [ymmRes1[255:128] ymmRes1[127:0] ymmRes0[255:128] ymmRes0[127:0]]
+        fprintf(fd,"            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);\n");
+        fprintf(fd,"             p_llrRes++;\n");
+        fprintf(fd,"}\n");
+    }
+
+    // =====================================================================
+    // Process group with 13 CNs
+
+
+fprintf(fd,  "// Process group with 13 CNs \n");
+
+ // Process group with 3 CNs
+
+    if (lut_numBnInBnGroups[12] > 0)
+    {
+        // If elements in group move to next address
+        idxBnGroup++;
+
+        // Number of groups of 32 BNs for parallel processing
+        M = (lut_numBnInBnGroups[12]*Z + 31)>>5;
+
+        // Set the offset to each CN within a group in terms of 16 Byte
+        cnOffsetInGroup = (lut_numBnInBnGroups[12]*NR_LDPC_ZMAX)>>4;
+
+        // Set pointers to start of group 2
+        fprintf(fd,"    p_bnProcBuf     = (__m128i*) &bnProcBuf    [%d];\n",lut_startAddrBnGroups[idxBnGroup]);
+        fprintf(fd,"    p_llrProcBuf    = (__m128i*) &llrProcBuf   [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+        fprintf(fd,"    p_llrRes        = (__m256i*) &llrRes       [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+        // Loop over BNs
+        fprintf(fd,"        for (int i=0,j=0;i<%d;i++,j+=2) {\n",M);
+            // First 16 LLRs of first CN
+        fprintf(fd,"        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);\n");
+        fprintf(fd,"        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);\n");
+
+            // Loop over CNs
+        for (k=1; k<13; k++)
+        {
+        fprintf(fd,"        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[%d + j]);\n", k*cnOffsetInGroup);
+        fprintf(fd,"        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);\n");
+
+        fprintf(fd,"        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[%d + j +1]);\n", k*cnOffsetInGroup);
+
+        fprintf(fd,"        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); \n");
+            }
+
+            // Add LLR from receiver input
+        fprintf(fd,"        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);\n");
+        fprintf(fd,"        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);\n");
+
+        fprintf(fd,"        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);\n");
+        fprintf(fd,"        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);\n");
+
+            // Pack results back to epi8
+        fprintf(fd,"        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);\n");
+            // ymm0     = [ymmRes1[255:128] ymmRes0[255:128] ymmRes1[127:0] ymmRes0[127:0]]
+            // p_llrRes = [ymmRes1[255:128] ymmRes1[127:0] ymmRes0[255:128] ymmRes0[127:0]]
+        fprintf(fd,"            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);\n");
+        fprintf(fd,"             p_llrRes++;\n");
+        fprintf(fd,"}\n");
+    }
+
+
+
+    // =====================================================================
+    // Process group with 4 CNs
+
+fprintf(fd,  "// Process group with 14 CNs \n");
+
+ // Process group with 4 CNs
+
+    if (lut_numBnInBnGroups[13] > 0)
+    {
+        // If elements in group move to next address
+        idxBnGroup++;
+
+        // Number of groups of 32 BNs for parallel processing
+        M = (lut_numBnInBnGroups[13]*Z + 31)>>5;
+
+        // Set the offset to each CN within a group in terms of 16 Byte
+        cnOffsetInGroup = (lut_numBnInBnGroups[13]*NR_LDPC_ZMAX)>>4;
+
+        // Set pointers to start of group 2
+        fprintf(fd,"    p_bnProcBuf     = (__m128i*) &bnProcBuf    [%d];\n",lut_startAddrBnGroups[idxBnGroup]);
+        fprintf(fd,"    p_llrProcBuf    = (__m128i*) &llrProcBuf   [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+        fprintf(fd,"    p_llrRes        = (__m256i*) &llrRes       [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+        // Loop over BNs
+        fprintf(fd,"        for (int i=0,j=0;i<%d;i++,j+=2) {\n",M);
+            // First 16 LLRs of first CN
+        fprintf(fd,"        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);\n");
+        fprintf(fd,"        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);\n");
+
+            // Loop over CNs
+        for (k=1; k<14; k++)
+        {
+        fprintf(fd,"        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[%d + j]);\n", k*cnOffsetInGroup);
+        fprintf(fd,"        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);\n");
+
+        fprintf(fd,"        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[%d + j +1]);\n", k*cnOffsetInGroup);
+
+        fprintf(fd, "       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); \n");
+        }
+
+            // Add LLR from receiver input
+        fprintf(fd,"        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);\n");
+        fprintf(fd,"        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);\n");
+
+        fprintf(fd,"        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);\n");
+        fprintf(fd,"        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);\n");
+
+            // Pack results back to epi8
+        fprintf(fd,"        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);\n");
+            // ymm0     = [ymmRes1[255:128] ymmRes0[255:128] ymmRes1[127:0] ymmRes0[127:0]]
+            // p_llrRes = [ymmRes1[255:128] ymmRes1[127:0] ymmRes0[255:128] ymmRes0[127:0]]
+        fprintf(fd,"            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);\n");
+        fprintf(fd,"             p_llrRes++;\n");
+        fprintf(fd,"}\n");
+    }
+
+
+   // =====================================================================
+    // Process group with 5 CNs
+    
+fprintf(fd,  "// Process group with 15 CNs \n");
+
+ // Process group with 5 CNs
+
+    if (lut_numBnInBnGroups[14] > 0)
+    {
+        // If elements in group move to next address
+        idxBnGroup++;
+
+        // Number of groups of 32 BNs for parallel processing
+        M = (lut_numBnInBnGroups[14]*Z + 31)>>5;
+
+        // Set the offset to each CN within a group in terms of 16 Byte
+        cnOffsetInGroup = (lut_numBnInBnGroups[14]*NR_LDPC_ZMAX)>>4;
+
+        // Set pointers to start of group 2
+        fprintf(fd,"    p_bnProcBuf     = (__m128i*) &bnProcBuf    [%d];\n",lut_startAddrBnGroups[idxBnGroup]);
+        fprintf(fd,"    p_llrProcBuf    = (__m128i*) &llrProcBuf   [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+        fprintf(fd,"    p_llrRes        = (__m256i*) &llrRes       [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+        // Loop over BNs
+        fprintf(fd,"        for (int i=0,j=0;i<%d;i++,j+=2) {\n",M);
+            // First 16 LLRs of first CN
+        fprintf(fd,"        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);\n");
+        fprintf(fd,"        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);\n");
+
+            // Loop over CNs
+        for (k=1; k<15; k++)
+        {
+        fprintf(fd,"        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[%d + j]);\n", k*cnOffsetInGroup);
+        fprintf(fd,"        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);\n");
+
+        fprintf(fd,"        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[%d + j +1]);\n", k*cnOffsetInGroup);
+
+        fprintf(fd, "       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); \n");
+        }
+
+            // Add LLR from receiver input
+        fprintf(fd,"        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);\n");
+        fprintf(fd,"        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);\n");
+
+        fprintf(fd,"        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);\n");
+        fprintf(fd,"        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);\n");
+
+            // Pack results back to epi8
+        fprintf(fd,"        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);\n");
+            // ymm0     = [ymmRes1[255:128] ymmRes0[255:128] ymmRes1[127:0] ymmRes0[127:0]]
+            // p_llrRes = [ymmRes1[255:128] ymmRes1[127:0] ymmRes0[255:128] ymmRes0[127:0]]
+         fprintf(fd,"            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);\n");
+        fprintf(fd,"             p_llrRes++;\n");
+        fprintf(fd,"}\n");
+    }
+
+
+
+   // =====================================================================
+    // Process group with 6 CNs
+    
+fprintf(fd,  "// Process group with 16 CNs \n");
+
+ // Process group with 6 CNs
+
+    if (lut_numBnInBnGroups[15] > 0)
+    {
+        // If elements in group move to next address
+        idxBnGroup++;
+
+        // Number of groups of 32 BNs for parallel processing
+        M = (lut_numBnInBnGroups[15]*Z + 31)>>5;
+
+        // Set the offset to each CN within a group in terms of 16 Byte
+        cnOffsetInGroup = (lut_numBnInBnGroups[15]*NR_LDPC_ZMAX)>>4;
+
+        // Set pointers to start of group 2
+        fprintf(fd,"    p_bnProcBuf     = (__m128i*) &bnProcBuf    [%d];\n",lut_startAddrBnGroups[idxBnGroup]);
+        fprintf(fd,"    p_llrProcBuf    = (__m128i*) &llrProcBuf   [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+        fprintf(fd,"    p_llrRes        = (__m256i*) &llrRes       [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+        // Loop over BNs
+        fprintf(fd,"        for (int i=0,j=0;i<%d;i++,j+=2) {\n",M);
+            // First 16 LLRs of first CN
+        fprintf(fd,"        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);\n");
+        fprintf(fd,"        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);\n");
+
+            // Loop over CNs
+        for (k=1; k<16; k++)
+        {
+        fprintf(fd,"        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[%d + j]);\n", k*cnOffsetInGroup);
+        fprintf(fd,"        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);\n");
+
+        fprintf(fd,"        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[%d + j +1]);\n", k*cnOffsetInGroup);
+
+        fprintf(fd, "       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); \n");
+        }
+
+            // Add LLR from receiver input
+        fprintf(fd,"        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);\n");
+        fprintf(fd,"        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);\n");
+
+        fprintf(fd,"        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);\n");
+        fprintf(fd,"        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);\n");
+
+            // Pack results back to epi8
+        fprintf(fd,"        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);\n");
+            // ymm0     = [ymmRes1[255:128] ymmRes0[255:128] ymmRes1[127:0] ymmRes0[127:0]]
+            // p_llrRes = [ymmRes1[255:128] ymmRes1[127:0] ymmRes0[255:128] ymmRes0[127:0]]
+        fprintf(fd,"            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);\n");
+        fprintf(fd,"             p_llrRes++;\n");
+        fprintf(fd,"}\n");
+    }
+
+
+   // =====================================================================
+    // Process group with 17 CNs
+    
+fprintf(fd,  "// Process group with 17 CNs \n");
+
+ // Process group with 17 CNs
+
+    if (lut_numBnInBnGroups[16] > 0)
+    {
+        // If elements in group move to next address
+        idxBnGroup++;
+
+        // Number of groups of 32 BNs for parallel processing
+        M = (lut_numBnInBnGroups[16]*Z + 31)>>5;
+
+        // Set the offset to each CN within a group in terms of 16 Byte
+        cnOffsetInGroup = (lut_numBnInBnGroups[16]*NR_LDPC_ZMAX)>>4;
+
+        // Set pointers to start of group 2
+        fprintf(fd,"    p_bnProcBuf     = (__m128i*) &bnProcBuf    [%d];\n",lut_startAddrBnGroups[idxBnGroup]);
+        fprintf(fd,"    p_llrProcBuf    = (__m128i*) &llrProcBuf   [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+        fprintf(fd,"    p_llrRes        = (__m256i*) &llrRes       [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+        // Loop over BNs
+        fprintf(fd,"        for (int i=0,j=0;i<%d;i++,j+=2) {\n",M);
+            // First 16 LLRs of first CN
+        fprintf(fd,"        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);\n");
+        fprintf(fd,"        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);\n");
+
+            // Loop over CNs
+        for (k=1; k<17; k++)
+        {
+        fprintf(fd,"        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[%d + j]);\n", k*cnOffsetInGroup);
+        fprintf(fd,"        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);\n");
+
+        fprintf(fd,"        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[%d + j +1]);\n", k*cnOffsetInGroup);
+
+        fprintf(fd, "       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); \n");
+        }
+
+            // Add LLR from receiver input
+        fprintf(fd,"        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);\n");
+        fprintf(fd,"        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);\n");
+
+        fprintf(fd,"        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);\n");
+        fprintf(fd,"        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);\n");
+
+            // Pack results back to epi8
+        fprintf(fd,"        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);\n");
+            // ymm0     = [ymmRes1[255:128] ymmRes0[255:128] ymmRes1[127:0] ymmRes0[127:0]]
+            // p_llrRes = [ymmRes1[255:128] ymmRes1[127:0] ymmRes0[255:128] ymmRes0[127:0]]
+        fprintf(fd,"            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);\n");
+        fprintf(fd,"             p_llrRes++;\n");
+        fprintf(fd,"}\n");
+    }
+
+
+   // =====================================================================
+    // Process group with 18 CNs
+    
+fprintf(fd,  "// Process group with 18 CNs \n");
+
+ // Process group with 8 CNs
+
+    if (lut_numBnInBnGroups[17] > 0)
+    {
+        // If elements in group move to next address
+        idxBnGroup++;
+
+        // Number of groups of 32 BNs for parallel processing
+        M = (lut_numBnInBnGroups[17]*Z + 31)>>5;
+
+        // Set the offset to each CN within a group in terms of 16 Byte
+        cnOffsetInGroup = (lut_numBnInBnGroups[17]*NR_LDPC_ZMAX)>>4;
+
+        // Set pointers to start of group 2
+        fprintf(fd,"    p_bnProcBuf     = (__m128i*) &bnProcBuf    [%d];\n",lut_startAddrBnGroups[idxBnGroup]);
+        fprintf(fd,"    p_llrProcBuf    = (__m128i*) &llrProcBuf   [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+        fprintf(fd,"    p_llrRes        = (__m256i*) &llrRes       [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+        // Loop over BNs
+        fprintf(fd,"        for (int i=0,j=0;i<%d;i++,j+=2) {\n",M);
+            // First 16 LLRs of first CN
+        fprintf(fd,"        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);\n");
+        fprintf(fd,"        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);\n");
+
+            // Loop over CNs
+        for (k=1; k<18; k++)
+        {
+        fprintf(fd,"        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[%d + j]);\n", k*cnOffsetInGroup);
+        fprintf(fd,"        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);\n");
+
+        fprintf(fd,"        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[%d + j +1]);\n", k*cnOffsetInGroup);
+
+        fprintf(fd, "       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); \n");
+        }
+
+            // Add LLR from receiver input
+        fprintf(fd,"        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);\n");
+        fprintf(fd,"        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);\n");
+
+        fprintf(fd,"        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);\n");
+        fprintf(fd,"        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);\n");
+
+            // Pack results back to epi8
+        fprintf(fd,"        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);\n");
+            // ymm0     = [ymmRes1[255:128] ymmRes0[255:128] ymmRes1[127:0] ymmRes0[127:0]]
+            // p_llrRes = [ymmRes1[255:128] ymmRes1[127:0] ymmRes0[255:128] ymmRes0[127:0]]
+        fprintf(fd,"            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);\n");
+        fprintf(fd,"             p_llrRes++;\n");
+        fprintf(fd,"}\n");
+    }
+
+   // =====================================================================
+    // Process group with 9 CNs
+    
+fprintf(fd,  "// Process group with 19 CNs \n");
+
+ // Process group with 9 CNs
+
+    if (lut_numBnInBnGroups[18] > 0)
+    {
+        // If elements in group move to next address
+        idxBnGroup++;
+
+        // Number of groups of 32 BNs for parallel processing
+        M = (lut_numBnInBnGroups[18]*Z + 31)>>5;
+
+        // Set the offset to each CN within a group in terms of 16 Byte
+        cnOffsetInGroup = (lut_numBnInBnGroups[18]*NR_LDPC_ZMAX)>>4;
+
+        // Set pointers to start of group 2
+        fprintf(fd,"    p_bnProcBuf     = (__m128i*) &bnProcBuf    [%d];\n",lut_startAddrBnGroups[idxBnGroup]);
+        fprintf(fd,"    p_llrProcBuf    = (__m128i*) &llrProcBuf   [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+        fprintf(fd,"    p_llrRes        = (__m256i*) &llrRes       [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+        // Loop over BNs
+        fprintf(fd,"        for (int i=0,j=0;i<%d;i++,j+=2) {\n",M);
+            // First 16 LLRs of first CN
+        fprintf(fd,"        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);\n");
+        fprintf(fd,"        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);\n");
+
+            // Loop over CNs
+        for (k=1; k<19; k++)
+        {
+        fprintf(fd,"        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[%d + j]);\n", k*cnOffsetInGroup);
+        fprintf(fd,"        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);\n");
+
+        fprintf(fd,"        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[%d + j +1]);\n", k*cnOffsetInGroup);
+
+        fprintf(fd, "       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); \n");
+        }
+
+            // Add LLR from receiver input
+        fprintf(fd,"        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);\n");
+        fprintf(fd,"        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);\n");
+
+        fprintf(fd,"        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);\n");
+        fprintf(fd,"        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);\n");
+
+            // Pack results back to epi8
+        fprintf(fd,"        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);\n");
+            // ymm0     = [ymmRes1[255:128] ymmRes0[255:128] ymmRes1[127:0] ymmRes0[127:0]]
+            // p_llrRes = [ymmRes1[255:128] ymmRes1[127:0] ymmRes0[255:128] ymmRes0[127:0]]
+        fprintf(fd,"            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);\n");
+        fprintf(fd,"             p_llrRes++;\n");
+        fprintf(fd,"}\n");
+    }
+
+
+   // =====================================================================
+    // Process group with 20 CNs
+    
+fprintf(fd,  "// Process group with 20 CNs \n");
+
+ // Process group with 20 CNs
+
+    if (lut_numBnInBnGroups[19] > 0)
+    {
+        // If elements in group move to next address
+        idxBnGroup++;
+
+        // Number of groups of 32 BNs for parallel processing
+        M = (lut_numBnInBnGroups[19]*Z + 31)>>5;
+
+        // Set the offset to each CN within a group in terms of 16 Byte
+        cnOffsetInGroup = (lut_numBnInBnGroups[19]*NR_LDPC_ZMAX)>>4;
+
+        // Set pointers to start of group 2
+        fprintf(fd,"    p_bnProcBuf     = (__m128i*) &bnProcBuf    [%d];\n",lut_startAddrBnGroups[idxBnGroup]);
+        fprintf(fd,"    p_llrProcBuf    = (__m128i*) &llrProcBuf   [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+        fprintf(fd,"    p_llrRes        = (__m256i*) &llrRes       [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+        // Loop over BNs
+        fprintf(fd,"        for (int i=0,j=0;i<%d;i++,j+=2) {\n",M);
+            // First 16 LLRs of first CN
+        fprintf(fd,"        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);\n");
+        fprintf(fd,"        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);\n");
+
+            // Loop over CNs
+        for (k=1; k<20; k++)
+        {
+        fprintf(fd,"        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[%d + j]);\n", k*cnOffsetInGroup);
+        fprintf(fd,"        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);\n");
+
+        fprintf(fd,"        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[%d + j +1]);\n", k*cnOffsetInGroup);
+
+        fprintf(fd, "       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); \n");
+        }
+
+            // Add LLR from receiver input
+        fprintf(fd,"        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);\n");
+        fprintf(fd,"        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);\n");
+
+        fprintf(fd,"        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);\n");
+        fprintf(fd,"        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);\n");
+
+            // Pack results back to epi8
+        fprintf(fd,"        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);\n");
+            // ymm0     = [ymmRes1[255:128] ymmRes0[255:128] ymmRes1[127:0] ymmRes0[127:0]]
+            // p_llrRes = [ymmRes1[255:128] ymmRes1[127:0] ymmRes0[255:128] ymmRes0[127:0]]
+        fprintf(fd,"            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);\n");
+        fprintf(fd,"             p_llrRes++;\n");
+        fprintf(fd,"}\n");
+    }
+
+
+
+
+
+    // =====================================================================
+   
+fprintf(fd,  "// Process group with 21 CNs \n");
+
+
+
+ // Process group with 2 CNs
+
+    if (lut_numBnInBnGroups[20] > 0)
+    {
+        // If elements in group move to next address
+        idxBnGroup++;
+
+        // Number of groups of 32 BNs for parallel processing
+        M = (lut_numBnInBnGroups[20]*Z + 31)>>5;
+
+        // Set the offset to each CN within a group in terms of 16 Byte
+        cnOffsetInGroup = (lut_numBnInBnGroups[20]*NR_LDPC_ZMAX)>>4;
+
+        // Set pointers to start of group 2
+        fprintf(fd,"    p_bnProcBuf     = (__m128i*) &bnProcBuf    [%d];\n",lut_startAddrBnGroups[idxBnGroup]);
+        fprintf(fd,"    p_llrProcBuf    = (__m128i*) &llrProcBuf   [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+        fprintf(fd,"    p_llrRes        = (__m256i*) &llrRes       [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+        // Loop over BNs
+        fprintf(fd,"            for (int i=0,j=0;i<%d;i++,j+=2) {\n",M);
+            // First 16 LLRs of first CN
+        fprintf(fd,"            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);\n");
+        fprintf(fd,"            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);\n");
+
+            // Loop over CNs
+        for (k=1; k<21; k++)
+        {
+        fprintf(fd,"            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[%d + j]);\n", k*cnOffsetInGroup);
+        fprintf(fd,"            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);\n");
+
+        fprintf(fd,"            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[%d + j +1]);\n", k*cnOffsetInGroup);
+
+        fprintf(fd, "           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); \n");
+        }
+
+            // Add LLR from receiver input
+        fprintf(fd,"            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);\n");
+        fprintf(fd,"            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);\n");
+
+        fprintf(fd,"            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);\n");
+        fprintf(fd,"            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);\n");
+
+            // Pack results back to epi8
+        fprintf(fd,"            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);\n");
+            // ymm0     = [ymmRes1[255:128] ymmRes0[255:128] ymmRes1[127:0] ymmRes0[127:0]]
+            // p_llrRes = [ymmRes1[255:128] ymmRes1[127:0] ymmRes0[255:128] ymmRes0[127:0]]
+        fprintf(fd,"            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);\n");
+        fprintf(fd,"             p_llrRes++;\n");
+        fprintf(fd,"}\n");
+    }
+      // =====================================================================
+    // Process group with 2 CNs
+
+
+fprintf(fd,  "// Process group with 22 CNs \n");
+
+ // Process group with 2 CNs
+
+    if (lut_numBnInBnGroups[21] > 0)
+    {
+        // If elements in group move to next address
+        idxBnGroup++;
+
+        // Number of groups of 32 BNs for parallel processing
+        M = (lut_numBnInBnGroups[21]*Z + 31)>>5;
+
+        // Set the offset to each CN within a group in terms of 16 Byte
+        cnOffsetInGroup = (lut_numBnInBnGroups[21]*NR_LDPC_ZMAX)>>4;
+
+        // Set pointers to start of group 2
+        fprintf(fd,"    p_bnProcBuf     = (__m128i*) &bnProcBuf    [%d];\n",lut_startAddrBnGroups[idxBnGroup]);
+        fprintf(fd,"    p_llrProcBuf    = (__m128i*) &llrProcBuf   [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+        fprintf(fd,"    p_llrRes        = (__m256i*) &llrRes       [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+        // Loop over BNs
+        fprintf(fd,"            for (int i=0,j=0;i<%d;i++,j+=2) {\n",M);
+            // First 16 LLRs of first CN
+        fprintf(fd,"            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);\n");
+        fprintf(fd,"            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);\n");
+
+            // Loop over CNs
+        for (k=1; k<22; k++)
+        {
+        fprintf(fd,"            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[%d + j]);\n", k*cnOffsetInGroup);
+        fprintf(fd,"            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);\n");
+
+        fprintf(fd,"            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[%d + j +1]);\n", k*cnOffsetInGroup);
+
+        fprintf(fd, "           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); \n");
+        }
+
+            // Add LLR from receiver input
+        fprintf(fd,"            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);\n");
+        fprintf(fd,"            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);\n");
+
+        fprintf(fd,"            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);\n");
+        fprintf(fd,"            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);\n");
+
+            // Pack results back to epi8
+        fprintf(fd,"            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);\n");
+            // ymm0     = [ymmRes1[255:128] ymmRes0[255:128] ymmRes1[127:0] ymmRes0[127:0]]
+            // p_llrRes = [ymmRes1[255:128] ymmRes1[127:0] ymmRes0[255:128] ymmRes0[127:0]]
+         fprintf(fd,"            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);\n");
+        fprintf(fd,"             p_llrRes++;\n");
+        fprintf(fd,"}\n");
+    }
+
+    // =====================================================================
+    // Process group with 13 CNs
+
+
+fprintf(fd,  "// Process group with <23 CNs \n");
+
+ // Process group with 3 CNs
+
+    if (lut_numBnInBnGroups[22] > 0)
+    {
+        // If elements in group move to next address
+        idxBnGroup++;
+
+        // Number of groups of 32 BNs for parallel processing
+        M = (lut_numBnInBnGroups[22]*Z + 31)>>5;
+
+        // Set the offset to each CN within a group in terms of 16 Byte
+        cnOffsetInGroup = (lut_numBnInBnGroups[22]*NR_LDPC_ZMAX)>>4;
+
+        // Set pointers to start of group 2
+        fprintf(fd,"    p_bnProcBuf     = (__m128i*) &bnProcBuf    [%d];\n",lut_startAddrBnGroups[idxBnGroup]);
+        fprintf(fd,"    p_llrProcBuf    = (__m128i*) &llrProcBuf   [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+        fprintf(fd,"    p_llrRes        = (__m256i*) &llrRes       [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+        // Loop over BNs
+        fprintf(fd,"        for (int i=0,j=0;i<%d;i++,j+=2) {\n",M);
+            // First 16 LLRs of first CN
+        fprintf(fd,"        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);\n");
+        fprintf(fd,"        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);\n");
+
+            // Loop over CNs
+        for (k=1; k<23; k++)
+        {
+        fprintf(fd,"        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[%d + j]);\n", k*cnOffsetInGroup);
+        fprintf(fd,"        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);\n");
+
+        fprintf(fd,"        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[%d + j +1]);\n", k*cnOffsetInGroup);
+
+        fprintf(fd,"        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); \n");
+            }
+
+            // Add LLR from receiver input
+        fprintf(fd,"        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);\n");
+        fprintf(fd,"        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);\n");
+
+        fprintf(fd,"        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);\n");
+        fprintf(fd,"        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);\n");
+
+            // Pack results back to epi8
+        fprintf(fd,"        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);\n");
+            // ymm0     = [ymmRes1[255:128] ymmRes0[255:128] ymmRes1[127:0] ymmRes0[127:0]]
+            // p_llrRes = [ymmRes1[255:128] ymmRes1[127:0] ymmRes0[255:128] ymmRes0[127:0]]
+        fprintf(fd,"            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);\n");
+        fprintf(fd,"             p_llrRes++;\n");
+        fprintf(fd,"}\n");
+    }
+
+
+
+    // =====================================================================
+    // Process group with 4 CNs
+
+fprintf(fd,  "// Process group with 24 CNs \n");
+
+ // Process group with 4 CNs
+
+    if (lut_numBnInBnGroups[23] > 0)
+    {
+        // If elements in group move to next address
+        idxBnGroup++;
+
+        // Number of groups of 32 BNs for parallel processing
+        M = (lut_numBnInBnGroups[23]*Z + 31)>>5;
+
+        // Set the offset to each CN within a group in terms of 16 Byte
+        cnOffsetInGroup = (lut_numBnInBnGroups[23]*NR_LDPC_ZMAX)>>4;
+
+        // Set pointers to start of group 2
+        fprintf(fd,"    p_bnProcBuf     = (__m128i*) &bnProcBuf    [%d];\n",lut_startAddrBnGroups[idxBnGroup]);
+        fprintf(fd,"    p_llrProcBuf    = (__m128i*) &llrProcBuf   [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+        fprintf(fd,"    p_llrRes        = (__m256i*) &llrRes       [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+        // Loop over BNs
+        fprintf(fd,"        for (int i=0,j=0;i<%d;i++,j+=2) {\n",M);
+            // First 16 LLRs of first CN
+        fprintf(fd,"        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);\n");
+        fprintf(fd,"        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);\n");
+
+            // Loop over CNs
+        for (k=1; k<24; k++)
+        {
+        fprintf(fd,"        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[%d + j]);\n", k*cnOffsetInGroup);
+        fprintf(fd,"        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);\n");
+
+        fprintf(fd,"        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[%d + j +1]);\n", k*cnOffsetInGroup);
+
+        fprintf(fd, "       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); \n");
+        }
+
+            // Add LLR from receiver input
+        fprintf(fd,"        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);\n");
+        fprintf(fd,"        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);\n");
+
+        fprintf(fd,"        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);\n");
+        fprintf(fd,"        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);\n");
+
+            // Pack results back to epi8
+        fprintf(fd,"        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);\n");
+            // ymm0     = [ymmRes1[255:128] ymmRes0[255:128] ymmRes1[127:0] ymmRes0[127:0]]
+            // p_llrRes = [ymmRes1[255:128] ymmRes1[127:0] ymmRes0[255:128] ymmRes0[127:0]]
+        fprintf(fd,"            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);\n");
+        fprintf(fd,"             p_llrRes++;\n");
+        fprintf(fd,"}\n");
+    }
+
+
+   // =====================================================================
+    // Process group with 5 CNs
+    
+fprintf(fd,  "// Process group with 25 CNs \n");
+
+ // Process group with 5 CNs
+
+    if (lut_numBnInBnGroups[24] > 0)
+    {
+        // If elements in group move to next address
+        idxBnGroup++;
+
+        // Number of groups of 32 BNs for parallel processing
+        M = (lut_numBnInBnGroups[24]*Z + 31)>>5;
+
+        // Set the offset to each CN within a group in terms of 16 Byte
+        cnOffsetInGroup = (lut_numBnInBnGroups[24]*NR_LDPC_ZMAX)>>4;
+
+        // Set pointers to start of group 2
+        fprintf(fd,"    p_bnProcBuf     = (__m128i*) &bnProcBuf    [%d];\n",lut_startAddrBnGroups[idxBnGroup]);
+        fprintf(fd,"    p_llrProcBuf    = (__m128i*) &llrProcBuf   [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+        fprintf(fd,"    p_llrRes        = (__m256i*) &llrRes       [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+        // Loop over BNs
+        fprintf(fd,"        for (int i=0,j=0;i<%d;i++,j+=2) {\n",M);
+            // First 16 LLRs of first CN
+        fprintf(fd,"        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);\n");
+        fprintf(fd,"        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);\n");
+
+            // Loop over CNs
+        for (k=1; k<25; k++)
+        {
+        fprintf(fd,"        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[%d + j]);\n", k*cnOffsetInGroup);
+        fprintf(fd,"        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);\n");
+
+        fprintf(fd,"        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[%d + j +1]);\n", k*cnOffsetInGroup);
+
+        fprintf(fd, "       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); \n");
+        }
+
+            // Add LLR from receiver input
+        fprintf(fd,"        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);\n");
+        fprintf(fd,"        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);\n");
+
+        fprintf(fd,"        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);\n");
+        fprintf(fd,"        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);\n");
+
+            // Pack results back to epi8
+        fprintf(fd,"        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);\n");
+            // ymm0     = [ymmRes1[255:128] ymmRes0[255:128] ymmRes1[127:0] ymmRes0[127:0]]
+            // p_llrRes = [ymmRes1[255:128] ymmRes1[127:0] ymmRes0[255:128] ymmRes0[127:0]]
+        fprintf(fd,"            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);\n");
+        fprintf(fd,"             p_llrRes++;\n");
+        fprintf(fd,"}\n");
+    }
+
+
+
+   // =====================================================================
+    // Process group with 6 CNs
+    
+fprintf(fd,  "// Process group with 26 CNs \n");
+
+ // Process group with 6 CNs
+
+    if (lut_numBnInBnGroups[25] > 0)
+    {
+        // If elements in group move to next address
+        idxBnGroup++;
+
+        // Number of groups of 32 BNs for parallel processing
+        M = (lut_numBnInBnGroups[25]*Z + 31)>>5;
+
+        // Set the offset to each CN within a group in terms of 16 Byte
+        cnOffsetInGroup = (lut_numBnInBnGroups[25]*NR_LDPC_ZMAX)>>4;
+
+        // Set pointers to start of group 2
+        fprintf(fd,"    p_bnProcBuf     = (__m128i*) &bnProcBuf    [%d];\n",lut_startAddrBnGroups[idxBnGroup]);
+        fprintf(fd,"    p_llrProcBuf    = (__m128i*) &llrProcBuf   [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+        fprintf(fd,"    p_llrRes        = (__m256i*) &llrRes       [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+        // Loop over BNs
+        fprintf(fd,"        for (int i=0,j=0;i<%d;i++,j+=2) {\n",M);
+            // First 16 LLRs of first CN
+        fprintf(fd,"        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);\n");
+        fprintf(fd,"        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);\n");
+
+            // Loop over CNs
+        for (k=1; k<26; k++)
+        {
+        fprintf(fd,"        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[%d + j]);\n", k*cnOffsetInGroup);
+        fprintf(fd,"        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);\n");
+
+        fprintf(fd,"        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[%d + j +1]);\n", k*cnOffsetInGroup);
+
+        fprintf(fd, "       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); \n");
+        }
+
+            // Add LLR from receiver input
+        fprintf(fd,"        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);\n");
+        fprintf(fd,"        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);\n");
+
+        fprintf(fd,"        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);\n");
+        fprintf(fd,"        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);\n");
+
+            // Pack results back to epi8
+        fprintf(fd,"        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);\n");
+            // ymm0     = [ymmRes1[255:128] ymmRes0[255:128] ymmRes1[127:0] ymmRes0[127:0]]
+            // p_llrRes = [ymmRes1[255:128] ymmRes1[127:0] ymmRes0[255:128] ymmRes0[127:0]]
+        fprintf(fd,"            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);\n");
+        fprintf(fd,"             p_llrRes++;\n");
+        fprintf(fd,"}\n");
+    }
+
+
+   // =====================================================================
+    // Process group with 17 CNs
+    
+fprintf(fd,  "// Process group with 27 CNs \n");
+
+ // Process group with 17 CNs
+
+    if (lut_numBnInBnGroups[26] > 0)
+    {
+        // If elements in group move to next address
+        idxBnGroup++;
+
+        // Number of groups of 32 BNs for parallel processing
+        M = (lut_numBnInBnGroups[26]*Z + 31)>>5;
+
+        // Set the offset to each CN within a group in terms of 16 Byte
+        cnOffsetInGroup = (lut_numBnInBnGroups[26]*NR_LDPC_ZMAX)>>4;
+
+        // Set pointers to start of group 2
+        fprintf(fd,"    p_bnProcBuf     = (__m128i*) &bnProcBuf    [%d];\n",lut_startAddrBnGroups[idxBnGroup]);
+        fprintf(fd,"    p_llrProcBuf    = (__m128i*) &llrProcBuf   [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+        fprintf(fd,"    p_llrRes        = (__m256i*) &llrRes       [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+        // Loop over BNs
+        fprintf(fd,"        for (int i=0,j=0;i<%d;i++,j+=2) {\n",M);
+            // First 16 LLRs of first CN
+        fprintf(fd,"        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);\n");
+        fprintf(fd,"        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);\n");
+
+            // Loop over CNs
+        for (k=1; k<27; k++)
+        {
+        fprintf(fd,"        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[%d + j]);\n", k*cnOffsetInGroup);
+        fprintf(fd,"        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);\n");
+
+        fprintf(fd,"        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[%d + j +1]);\n", k*cnOffsetInGroup);
+
+        fprintf(fd, "       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); \n");
+        }
+
+            // Add LLR from receiver input
+        fprintf(fd,"        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);\n");
+        fprintf(fd,"        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);\n");
+
+        fprintf(fd,"        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);\n");
+        fprintf(fd,"        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);\n");
+
+            // Pack results back to epi8
+        fprintf(fd,"        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);\n");
+            // ymm0     = [ymmRes1[255:128] ymmRes0[255:128] ymmRes1[127:0] ymmRes0[127:0]]
+            // p_llrRes = [ymmRes1[255:128] ymmRes1[127:0] ymmRes0[255:128] ymmRes0[127:0]]
+        fprintf(fd,"            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);\n");
+        fprintf(fd,"             p_llrRes++;\n");
+        fprintf(fd,"}\n");
+    }
+
+
+   // =====================================================================
+    // Process group with 18 CNs
+    
+fprintf(fd,  "// Process group with 28 CNs \n");
+
+ // Process group with 8 CNs
+
+    if (lut_numBnInBnGroups[27] > 0)
+    {
+        // If elements in group move to next address
+        idxBnGroup++;
+
+        // Number of groups of 32 BNs for parallel processing
+        M = (lut_numBnInBnGroups[27]*Z + 31)>>5;
+
+        // Set the offset to each CN within a group in terms of 16 Byte
+        cnOffsetInGroup = (lut_numBnInBnGroups[27]*NR_LDPC_ZMAX)>>4;
+
+        // Set pointers to start of group 2
+        fprintf(fd,"    p_bnProcBuf     = (__m128i*) &bnProcBuf    [%d];\n",lut_startAddrBnGroups[idxBnGroup]);
+        fprintf(fd,"    p_llrProcBuf    = (__m128i*) &llrProcBuf   [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+        fprintf(fd,"    p_llrRes        = (__m256i*) &llrRes       [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+        // Loop over BNs
+        fprintf(fd,"        for (int i=0,j=0;i<%d;i++,j+=2) {\n",M);
+            // First 16 LLRs of first CN
+        fprintf(fd,"        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);\n");
+        fprintf(fd,"        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);\n");
+
+            // Loop over CNs
+        for (k=1; k<28; k++)
+        {
+        fprintf(fd,"        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[%d + j]);\n", k*cnOffsetInGroup);
+        fprintf(fd,"        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);\n");
+
+        fprintf(fd,"        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[%d + j +1]);\n", k*cnOffsetInGroup);
+
+        fprintf(fd, "       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); \n");
+        }
+
+            // Add LLR from receiver input
+        fprintf(fd,"        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);\n");
+        fprintf(fd,"        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);\n");
+
+        fprintf(fd,"        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);\n");
+        fprintf(fd,"        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);\n");
+
+            // Pack results back to epi8
+        fprintf(fd,"        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);\n");
+            // ymm0     = [ymmRes1[255:128] ymmRes0[255:128] ymmRes1[127:0] ymmRes0[127:0]]
+            // p_llrRes = [ymmRes1[255:128] ymmRes1[127:0] ymmRes0[255:128] ymmRes0[127:0]]
+        fprintf(fd,"            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);\n");
+        fprintf(fd,"             p_llrRes++;\n");
+        fprintf(fd,"}\n");
+    }
+
+   // =====================================================================
+    // Process group with 9 CNs
+    
+fprintf(fd,  "// Process group with 29 CNs \n");
+
+ // Process group with 9 CNs
+
+    if (lut_numBnInBnGroups[28] > 0)
+    {
+        // If elements in group move to next address
+        idxBnGroup++;
+
+        // Number of groups of 32 BNs for parallel processing
+        M = (lut_numBnInBnGroups[28]*Z + 31)>>5;
+
+        // Set the offset to each CN within a group in terms of 16 Byte
+        cnOffsetInGroup = (lut_numBnInBnGroups[28]*NR_LDPC_ZMAX)>>4;
+
+        // Set pointers to start of group 2
+        fprintf(fd,"    p_bnProcBuf     = (__m128i*) &bnProcBuf    [%d];\n",lut_startAddrBnGroups[idxBnGroup]);
+        fprintf(fd,"    p_llrProcBuf    = (__m128i*) &llrProcBuf   [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+        fprintf(fd,"    p_llrRes        = (__m256i*) &llrRes       [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+        // Loop over BNs
+        fprintf(fd,"        for (int i=0,j=0;i<%d;i++,j+=2) {\n",M);
+            // First 16 LLRs of first CN
+        fprintf(fd,"        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);\n");
+        fprintf(fd,"        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);\n");
+
+            // Loop over CNs
+        for (k=1; k<29; k++)
+        {
+        fprintf(fd,"        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[%d + j]);\n", k*cnOffsetInGroup);
+        fprintf(fd,"        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);\n");
+
+        fprintf(fd,"        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[%d + j +1]);\n", k*cnOffsetInGroup);
+
+        fprintf(fd, "       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); \n");
+        }
+
+            // Add LLR from receiver input
+        fprintf(fd,"        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);\n");
+        fprintf(fd,"        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);\n");
+
+        fprintf(fd,"        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);\n");
+        fprintf(fd,"        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);\n");
+
+            // Pack results back to epi8
+        fprintf(fd,"        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);\n");
+            // ymm0     = [ymmRes1[255:128] ymmRes0[255:128] ymmRes1[127:0] ymmRes0[127:0]]
+            // p_llrRes = [ymmRes1[255:128] ymmRes1[127:0] ymmRes0[255:128] ymmRes0[127:0]]
+        fprintf(fd,"            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);\n");
+        fprintf(fd,"             p_llrRes++;\n");
+        fprintf(fd,"}\n");
+    }
+
+
+   // =====================================================================
+    // Process group with 20 CNs
+    
+fprintf(fd,  "// Process group with 30 CNs \n");
+
+ // Process group with 20 CNs
+
+    if (lut_numBnInBnGroups[29] > 0)
+    {
+        // If elements in group move to next address
+        idxBnGroup++;
+
+        // Number of groups of 32 BNs for parallel processing
+        M = (lut_numBnInBnGroups[29]*Z + 31)>>5;
+
+        // Set the offset to each CN within a group in terms of 16 Byte
+        cnOffsetInGroup = (lut_numBnInBnGroups[29]*NR_LDPC_ZMAX)>>4;
+
+        // Set pointers to start of group 2
+        fprintf(fd,"    p_bnProcBuf     = (__m128i*) &bnProcBuf    [%d];\n",lut_startAddrBnGroups[idxBnGroup]);
+        fprintf(fd,"    p_llrProcBuf    = (__m128i*) &llrProcBuf   [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+        fprintf(fd,"    p_llrRes        = (__m256i*) &llrRes       [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+        // Loop over BNs
+        fprintf(fd,"        for (int i=0,j=0;i<%d;i++,j+=2) {\n",M);
+            // First 16 LLRs of first CN
+        fprintf(fd,"        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);\n");
+        fprintf(fd,"        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);\n");
+
+            // Loop over CNs
+        for (k=1; k<30; k++)
+        {
+        fprintf(fd,"        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[%d + j]);\n", k*cnOffsetInGroup);
+        fprintf(fd,"        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);\n");
+
+        fprintf(fd,"        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[%d + j +1]);\n", k*cnOffsetInGroup);
+
+        fprintf(fd, "       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); \n");
+        }
+
+            // Add LLR from receiver input
+        fprintf(fd,"        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);\n");
+        fprintf(fd,"        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);\n");
+
+        fprintf(fd,"        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);\n");
+        fprintf(fd,"        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);\n");
+
+            // Pack results back to epi8
+        fprintf(fd,"        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);\n");
+            // ymm0     = [ymmRes1[255:128] ymmRes0[255:128] ymmRes1[127:0] ymmRes0[127:0]]
+            // p_llrRes = [ymmRes1[255:128] ymmRes1[127:0] ymmRes0[255:128] ymmRes0[127:0]]
+        fprintf(fd,"            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);\n");
+        fprintf(fd,"             p_llrRes++;\n");
+        fprintf(fd,"}\n");
+    }
+
+    fprintf(fd,"}\n");
+  fclose(fd);
+}//end of the function  nrLDPC_bnProc_BG1
+
+
+
+
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_bnProc/bnProc_gen_BG1_avx2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_bnProc/bnProc_gen_BG1_avx2.c
new file mode 100644
index 0000000000..0fffb241af
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_bnProc/bnProc_gen_BG1_avx2.c
@@ -0,0 +1,1235 @@
+
+
+#include <stdint.h>
+#include <immintrin.h>
+#include "../../nrLDPCdecoder_defs.h"
+#include "../../nrLDPC_types.h"
+#include "../../nrLDPC_bnProc.h"
+#include "../../nrLDPC_cnProc.h"
+#include "../../nrLDPC_init.h"
+
+void nrLDPC_bnProc_BG1_generator_AVX2(uint16_t Z,int R)
+{
+  const char *ratestr[3]={"13","23","89"};
+
+  if (R<0 || R>2) {printf("Illegal R %d\n",R); abort();}
+
+
+ // system("mkdir -p ../ldpc_gen_files");
+
+  char fname[50];
+  sprintf(fname,"../ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z%d_R%s_AVX2.c",Z,ratestr[R]);
+  FILE *fd=fopen(fname,"w");
+  if (fd == NULL) {printf("Cannot create \n");abort();}
+
+  fprintf(fd,"#include <stdint.h>\n");
+  fprintf(fd,"#include <immintrin.h>\n");
+
+    
+    fprintf(fd,"void nrLDPC_bnProc_BG1_Z%d_R%s_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes,  int8_t* llrRes ) {\n",Z, ratestr[R]);
+    const uint8_t*  lut_numBnInBnGroups;
+    const uint32_t* lut_startAddrBnGroups;
+    const uint16_t* lut_startAddrBnGroupsLlr;
+    if (R==0) {
+
+
+      lut_numBnInBnGroups =  lut_numBnInBnGroups_BG1_R13;
+      lut_startAddrBnGroups = lut_startAddrBnGroups_BG1_R13;
+      lut_startAddrBnGroupsLlr = lut_startAddrBnGroupsLlr_BG1_R13;
+
+    }
+    else if (R==1){
+
+      lut_numBnInBnGroups =  lut_numBnInBnGroups_BG1_R23;
+      lut_startAddrBnGroups = lut_startAddrBnGroups_BG1_R23;
+      lut_startAddrBnGroupsLlr = lut_startAddrBnGroupsLlr_BG1_R23;
+    }
+    else if (R==2) {
+
+      lut_numBnInBnGroups = lut_numBnInBnGroups_BG1_R89;
+      lut_startAddrBnGroups = lut_startAddrBnGroups_BG1_R89;
+      lut_startAddrBnGroupsLlr = lut_startAddrBnGroupsLlr_BG1_R89;
+    }
+  else { printf("aborting, illegal R %d\n",R); fclose(fd);abort();}
+
+
+    uint32_t M;
+    //uint32_t M32rem;
+   // uint32_t i;
+    uint32_t k;
+    // Offset to each bit within a group in terms of 32 Byte
+    uint32_t cnOffsetInGroup;
+    uint8_t idxBnGroup = 0;
+
+
+    
+    fprintf(fd,"        __m256i* p_bnProcBuf; \n");
+    fprintf(fd,"        __m256i* p_bnProcBufRes; \n");
+    fprintf(fd,"        __m256i* p_llrRes; \n");
+    fprintf(fd,"        __m256i* p_res; \n");
+
+
+
+// =====================================================================
+    // Process group with 1 CN
+    // Already done in bnProcBufPc
+
+    // =====================================================================
+
+fprintf(fd,  "// Process group with 2 CNs \n");
+
+    if (lut_numBnInBnGroups[1] > 0)
+    {
+ // If elements in group move to next address
+        idxBnGroup++;
+
+        // Number of groups of 32 BNs for parallel processing
+        M = (lut_numBnInBnGroups[1]*Z + 31)>>5;
+
+        // Set the offset to each CN within a group in terms of 16 Byte
+        cnOffsetInGroup = (lut_numBnInBnGroups[1]*NR_LDPC_ZMAX)>>5;
+
+        // Set pointers to start of group 2
+        fprintf(fd,"    p_bnProcBuf     = (__m256i*) &bnProcBuf    [%d];\n",lut_startAddrBnGroups[idxBnGroup]);
+        fprintf(fd,"   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [%d];\n",lut_startAddrBnGroups[idxBnGroup]); 
+            
+            // Loop over CNs
+        for (k=0; k<2; k++)
+        {
+        fprintf(fd,"            p_res = &p_bnProcBufRes[%d];\n", k*cnOffsetInGroup);
+        fprintf(fd,"            p_llrRes = (__m256i*) &llrRes  [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+
+          // Loop over BNs
+        fprintf(fd,"            for (int i=0;i<%d;i++) {\n",M);
+        fprintf(fd,"            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[%d + i]);\n",k*cnOffsetInGroup);
+        fprintf(fd,"             p_res++;\n");
+        fprintf(fd,"             p_llrRes++;\n");
+
+         fprintf(fd,"}\n");
+        
+        }
+
+        
+       
+    }
+
+    // =====================================================================
+
+
+fprintf(fd,  "// Process group with 3 CNs \n");
+
+
+
+    if (lut_numBnInBnGroups[2] > 0)
+    {
+ // If elements in group move to next address
+        idxBnGroup++;
+
+        // Number of groups of 32 BNs for parallel processing
+        M = (lut_numBnInBnGroups[2]*Z + 31)>>5;
+
+        // Set the offset to each CN within a group in terms of 16 Byte
+        cnOffsetInGroup = (lut_numBnInBnGroups[2]*NR_LDPC_ZMAX)>>5;
+
+        // Set pointers to start of group 2
+        fprintf(fd,"    p_bnProcBuf     = (__m256i*) &bnProcBuf    [%d];\n",lut_startAddrBnGroups[idxBnGroup]);
+        fprintf(fd,"   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [%d];\n",lut_startAddrBnGroups[idxBnGroup]); 
+            
+        for (k=0; k<3; k++)
+        {
+        fprintf(fd,"            p_res = &p_bnProcBufRes[%d];\n", k*cnOffsetInGroup);
+        fprintf(fd,"            p_llrRes = (__m256i*) &llrRes  [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+
+          // Loop over BNs
+        fprintf(fd,"            for (int i=0;i<%d;i++) {\n",M);
+        fprintf(fd,"            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[%d + i]);\n",k*cnOffsetInGroup);
+        fprintf(fd,"            p_res++;\n");
+        fprintf(fd,"            p_llrRes++;\n");
+
+         fprintf(fd,"}\n");
+        }
+    }
+
+
+
+    // =====================================================================
+   
+
+fprintf(fd,  "// Process group with 4 CNs \n");
+
+ 
+
+    if (lut_numBnInBnGroups[3] > 0)
+    {
+        // If elements in group move to next address
+        idxBnGroup++;
+
+        // Number of groups of 32 BNs for parallel processing
+        M = (lut_numBnInBnGroups[3]*Z + 31)>>5;
+
+        // Set the offset to each CN within a group in terms of 16 Byte
+        cnOffsetInGroup = (lut_numBnInBnGroups[3]*NR_LDPC_ZMAX)>>5;
+
+        // Set pointers to start of group 2
+        fprintf(fd,"    p_bnProcBuf     = (__m256i*) &bnProcBuf    [%d];\n",lut_startAddrBnGroups[idxBnGroup]);
+        fprintf(fd,"   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [%d];\n",lut_startAddrBnGroups[idxBnGroup]); 
+            
+        for (k=0; k<4; k++)
+        {
+        fprintf(fd,"            p_res = &p_bnProcBufRes[%d];\n", k*cnOffsetInGroup);
+        fprintf(fd,"            p_llrRes = (__m256i*) &llrRes  [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+
+          // Loop over BNs
+        fprintf(fd,"            for (int i=0;i<%d;i++) {\n",M);
+        fprintf(fd,"            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[%d + i]);\n",k*cnOffsetInGroup);
+        fprintf(fd,"            p_res++;\n");
+        fprintf(fd,"            p_llrRes++;\n");
+
+         fprintf(fd,"}\n");
+        }
+    }
+
+
+   // =====================================================================
+
+    
+    fprintf(fd,  "// Process group with 5 CNs \n");
+
+
+
+    if (lut_numBnInBnGroups[4] > 0)
+    {
+    // If elements in group move to next address
+        idxBnGroup++;
+
+        // Number of groups of 32 BNs for parallel processing
+        M = (lut_numBnInBnGroups[4]*Z + 31)>>5;
+
+        // Set the offset to each CN within a group in terms of 16 Byte
+        cnOffsetInGroup = (lut_numBnInBnGroups[4]*NR_LDPC_ZMAX)>>5;
+
+        // Set pointers to start of group 2
+        fprintf(fd,"    p_bnProcBuf     = (__m256i*) &bnProcBuf    [%d];\n",lut_startAddrBnGroups[idxBnGroup]);
+        fprintf(fd,"   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [%d];\n",lut_startAddrBnGroups[idxBnGroup]); 
+            
+            // Loop over CNs
+        for (k=0; k<5; k++)
+        {
+        fprintf(fd,"            p_res = &p_bnProcBufRes[%d];\n", k*cnOffsetInGroup);
+        fprintf(fd,"            p_llrRes = (__m256i*) &llrRes  [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+
+          // Loop over BNs
+        fprintf(fd,"            for (int i=0;i<%d;i++) {\n",M);
+        fprintf(fd,"            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[%d + i]);\n",k*cnOffsetInGroup);
+        fprintf(fd,"            p_res++;\n");
+        fprintf(fd,"            p_llrRes++;\n");
+
+         fprintf(fd,"}\n");
+        
+        }
+    }
+
+
+
+   // =====================================================================
+ 
+    
+fprintf(fd,  "// Process group with 6 CNs \n");
+
+ // Process group with 6 CNs
+
+    if (lut_numBnInBnGroups[5] > 0)
+    {
+  // If elements in group move to next address
+        idxBnGroup++;
+
+        // Number of groups of 32 BNs for parallel processing
+        M = (lut_numBnInBnGroups[5]*Z + 31)>>5;
+
+        // Set the offset to each CN within a group in terms of 16 Byte
+        cnOffsetInGroup = (lut_numBnInBnGroups[5]*NR_LDPC_ZMAX)>>5;
+
+        // Set pointers to start of group 2
+        fprintf(fd,"    p_bnProcBuf     = (__m256i*) &bnProcBuf    [%d];\n",lut_startAddrBnGroups[idxBnGroup]);
+        fprintf(fd,"   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [%d];\n",lut_startAddrBnGroups[idxBnGroup]); 
+            
+            // Loop over CNs
+        for (k=0; k<6; k++)
+        {
+        fprintf(fd,"            p_res = &p_bnProcBufRes[%d];\n", k*cnOffsetInGroup);
+        fprintf(fd,"            p_llrRes = (__m256i*) &llrRes  [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+
+          // Loop over BNs
+        fprintf(fd,"            for (int i=0;i<%d;i++) {\n",M);
+        fprintf(fd,"            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[%d + i]);\n",k*cnOffsetInGroup);
+        fprintf(fd,"            p_res++;\n");
+        fprintf(fd,"            p_llrRes++;\n");
+
+         fprintf(fd,"}\n");
+        
+        }
+    }
+
+
+   // =====================================================================
+
+    
+fprintf(fd,  "// Process group with 7 CNs \n");
+
+ // Process group with 7 CNs
+
+    if (lut_numBnInBnGroups[6] > 0)
+    {
+  // If elements in group move to next address
+        idxBnGroup++;
+
+        // Number of groups of 32 BNs for parallel processing
+        M = (lut_numBnInBnGroups[6]*Z + 31)>>5;
+
+        // Set the offset to each CN within a group in terms of 16 Byte
+        cnOffsetInGroup = (lut_numBnInBnGroups[6]*NR_LDPC_ZMAX)>>5;
+
+        // Set pointers to start of group 2
+        fprintf(fd,"    p_bnProcBuf     = (__m256i*) &bnProcBuf    [%d];\n",lut_startAddrBnGroups[idxBnGroup]);
+        fprintf(fd,"   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [%d];\n",lut_startAddrBnGroups[idxBnGroup]); 
+            
+            // Loop over CNs
+        for (k=0; k<7; k++)
+        {
+        fprintf(fd,"            p_res = &p_bnProcBufRes[%d];\n", k*cnOffsetInGroup);
+        fprintf(fd,"            p_llrRes = (__m256i*) &llrRes  [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+
+          // Loop over BNs
+        fprintf(fd,"            for (int i=0;i<%d;i++) {\n",M);
+        fprintf(fd,"            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[%d + i]);\n",k*cnOffsetInGroup);
+        fprintf(fd,"            p_res++;\n");
+        fprintf(fd,"            p_llrRes++;\n");
+
+         fprintf(fd,"}\n");
+        
+        }
+    }
+
+
+   // =====================================================================
+ 
+    
+fprintf(fd,  "// Process group with 8 CNs \n");
+
+ // Process group with 8 CNs
+
+    if (lut_numBnInBnGroups[7] > 0)
+    {
+ // If elements in group move to next address
+        idxBnGroup++;
+
+        // Number of groups of 32 BNs for parallel processing
+        M = (lut_numBnInBnGroups[7]*Z + 31)>>5;
+
+        // Set the offset to each CN within a group in terms of 16 Byte
+        cnOffsetInGroup = (lut_numBnInBnGroups[7]*NR_LDPC_ZMAX)>>5;
+
+        // Set pointers to start of group 2
+        fprintf(fd,"    p_bnProcBuf     = (__m256i*) &bnProcBuf    [%d];\n",lut_startAddrBnGroups[idxBnGroup]);
+        fprintf(fd,"   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [%d];\n",lut_startAddrBnGroups[idxBnGroup]); 
+            
+            // Loop over CNs
+        for (k=0; k<8; k++)
+        {
+        fprintf(fd,"            p_res = &p_bnProcBufRes[%d];\n", k*cnOffsetInGroup);
+        fprintf(fd,"            p_llrRes = (__m256i*) &llrRes  [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+
+          // Loop over BNs
+        fprintf(fd,"            for (int i=0;i<%d;i++) {\n",M);
+        fprintf(fd,"            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[%d + i]);\n",k*cnOffsetInGroup);
+        fprintf(fd,"            p_res++;\n");
+        fprintf(fd,"            p_llrRes++;\n");
+
+         fprintf(fd,"}\n");
+        
+        }
+    }
+
+   // =====================================================================
+
+    
+fprintf(fd,  "// Process group with 9 CNs \n");
+
+ // Process group with 9 CNs
+
+    if (lut_numBnInBnGroups[8] > 0)
+    {
+  // If elements in group move to next address
+        idxBnGroup++;
+
+        // Number of groups of 32 BNs for parallel processing
+        M = (lut_numBnInBnGroups[8]*Z + 31)>>5;
+
+        // Set the offset to each CN within a group in terms of 16 Byte
+        cnOffsetInGroup = (lut_numBnInBnGroups[8]*NR_LDPC_ZMAX)>>5;
+
+        // Set pointers to start of group 2
+        fprintf(fd,"    p_bnProcBuf     = (__m256i*) &bnProcBuf    [%d];\n",lut_startAddrBnGroups[idxBnGroup]);
+        fprintf(fd,"   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [%d];\n",lut_startAddrBnGroups[idxBnGroup]); 
+            
+            // Loop over CNs
+        for (k=0; k<9; k++)
+        {
+        fprintf(fd,"            p_res = &p_bnProcBufRes[%d];\n", k*cnOffsetInGroup);
+        fprintf(fd,"            p_llrRes = (__m256i*) &llrRes  [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+
+          // Loop over BNs
+        fprintf(fd,"            for (int i=0;i<%d;i++) {\n",M);
+        fprintf(fd,"            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[%d + i]);\n",k*cnOffsetInGroup);
+        fprintf(fd,"            p_res++;\n");
+        fprintf(fd,"            p_llrRes++;\n");
+
+         fprintf(fd,"}\n");
+        
+        }
+    }
+
+
+   // =====================================================================
+
+fprintf(fd,  "// Process group with 10 CNs \n");
+
+ // Process group with 10 CNs
+
+    if (lut_numBnInBnGroups[9] > 0)
+    {
+ // If elements in group move to next address
+        idxBnGroup++;
+
+        // Number of groups of 32 BNs for parallel processing
+        M = (lut_numBnInBnGroups[9]*Z + 31)>>5;
+
+        // Set the offset to each CN within a group in terms of 16 Byte
+        cnOffsetInGroup = (lut_numBnInBnGroups[9]*NR_LDPC_ZMAX)>>5;
+
+        // Set pointers to start of group 2
+        fprintf(fd,"    p_bnProcBuf     = (__m256i*) &bnProcBuf    [%d];\n",lut_startAddrBnGroups[idxBnGroup]);
+        fprintf(fd,"   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [%d];\n",lut_startAddrBnGroups[idxBnGroup]); 
+            
+            // Loop over CNs
+        for (k=0; k<10; k++)
+        {
+        fprintf(fd,"            p_res = &p_bnProcBufRes[%d];\n", k*cnOffsetInGroup);
+        fprintf(fd,"            p_llrRes = (__m256i*) &llrRes  [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+
+          // Loop over BNs
+        fprintf(fd,"            for (int i=0;i<%d;i++) {\n",M);
+        fprintf(fd,"            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[%d + i]);\n",k*cnOffsetInGroup);
+        fprintf(fd,"            p_res++;\n");
+        fprintf(fd,"            p_llrRes++;\n");
+
+         fprintf(fd,"}\n");
+        
+        }
+    }
+
+
+
+    // =====================================================================
+   
+fprintf(fd,  "// Process group with 11 CNs \n");
+
+    if (lut_numBnInBnGroups[10] > 0)
+    {
+  // If elements in group move to next address
+        idxBnGroup++;
+
+        // Number of groups of 32 BNs for parallel processing
+        M = (lut_numBnInBnGroups[10]*Z + 31)>>5;
+
+        // Set the offset to each CN within a group in terms of 16 Byte
+        cnOffsetInGroup = (lut_numBnInBnGroups[10]*NR_LDPC_ZMAX)>>5;
+
+        // Set pointers to start of group 2
+        fprintf(fd,"    p_bnProcBuf     = (__m256i*) &bnProcBuf    [%d];\n",lut_startAddrBnGroups[idxBnGroup]);
+        fprintf(fd,"   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [%d];\n",lut_startAddrBnGroups[idxBnGroup]); 
+            
+            // Loop over CNs
+        for (k=0; k<11; k++)
+        {
+        fprintf(fd,"            p_res = &p_bnProcBufRes[%d];\n", k*cnOffsetInGroup);
+        fprintf(fd,"            p_llrRes = (__m256i*) &llrRes  [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+
+          // Loop over BNs
+        fprintf(fd,"            for (int i=0;i<%d;i++) {\n",M);
+        fprintf(fd,"            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[%d + i]);\n",k*cnOffsetInGroup);
+        fprintf(fd,"            p_res++;\n");
+        fprintf(fd,"            p_llrRes++;\n");
+
+         fprintf(fd,"}\n");
+        
+        }
+    }
+      // =====================================================================
+
+
+
+fprintf(fd,  "// Process group with 12 CNs \n");
+
+
+    if (lut_numBnInBnGroups[11] > 0)
+    {
+  // If elements in group move to next address
+        idxBnGroup++;
+
+        // Number of groups of 32 BNs for parallel processing
+        M = (lut_numBnInBnGroups[11]*Z + 31)>>5;
+
+        // Set the offset to each CN within a group in terms of 16 Byte
+        cnOffsetInGroup = (lut_numBnInBnGroups[11]*NR_LDPC_ZMAX)>>5;
+
+        // Set pointers to start of group 2
+        fprintf(fd,"    p_bnProcBuf     = (__m256i*) &bnProcBuf    [%d];\n",lut_startAddrBnGroups[idxBnGroup]);
+        fprintf(fd,"   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [%d];\n",lut_startAddrBnGroups[idxBnGroup]); 
+            
+            // Loop over CNs
+        for (k=0; k<12; k++)
+        {
+        fprintf(fd,"            p_res = &p_bnProcBufRes[%d];\n", k*cnOffsetInGroup);
+        fprintf(fd,"            p_llrRes = (__m256i*) &llrRes  [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+
+          // Loop over BNs
+        fprintf(fd,"            for (int i=0;i<%d;i++) {\n",M);
+        fprintf(fd,"            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[%d + i]);\n",k*cnOffsetInGroup);
+        fprintf(fd,"            p_res++;\n");
+        fprintf(fd,"            p_llrRes++;\n");
+
+         fprintf(fd,"}\n");
+        
+        }
+    }
+
+    // =====================================================================
+
+
+
+fprintf(fd,  "// Process group with 13 CNs \n");
+
+
+
+    if (lut_numBnInBnGroups[12] > 0)
+    {
+  // If elements in group move to next address
+        idxBnGroup++;
+
+        // Number of groups of 32 BNs for parallel processing
+        M = (lut_numBnInBnGroups[12]*Z + 31)>>5;
+
+        // Set the offset to each CN within a group in terms of 16 Byte
+        cnOffsetInGroup = (lut_numBnInBnGroups[12]*NR_LDPC_ZMAX)>>5;
+
+        // Set pointers to start of group 2
+        fprintf(fd,"    p_bnProcBuf     = (__m256i*) &bnProcBuf    [%d];\n",lut_startAddrBnGroups[idxBnGroup]);
+        fprintf(fd,"   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [%d];\n",lut_startAddrBnGroups[idxBnGroup]); 
+            
+            // Loop over CNs
+        for (k=0; k<1; k++)
+        {
+        fprintf(fd,"            p_res = &p_bnProcBufRes[%d];\n", k*cnOffsetInGroup);
+        fprintf(fd,"            p_llrRes = (__m256i*) &llrRes  [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+
+          // Loop over BNs
+        fprintf(fd,"            for (int i=0;i<%d;i++) {\n",M);
+        fprintf(fd,"            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[%d + i]);\n",k*cnOffsetInGroup);
+        fprintf(fd,"            p_res++;\n");
+        fprintf(fd,"            p_llrRes++;\n");
+
+         fprintf(fd,"}\n");
+        
+        }
+    }
+
+
+
+    // =====================================================================
+   
+
+fprintf(fd,  "// Process group with 14 CNs \n");
+
+
+
+    if (lut_numBnInBnGroups[13] > 0)
+    {
+  // If elements in group move to next address
+        idxBnGroup++;
+
+        // Number of groups of 32 BNs for parallel processing
+        M = (lut_numBnInBnGroups[13]*Z + 31)>>5;
+
+        // Set the offset to each CN within a group in terms of 16 Byte
+        cnOffsetInGroup = (lut_numBnInBnGroups[13]*NR_LDPC_ZMAX)>>5;
+
+        // Set pointers to start of group 2
+        fprintf(fd,"    p_bnProcBuf     = (__m256i*) &bnProcBuf    [%d];\n",lut_startAddrBnGroups[idxBnGroup]);
+        fprintf(fd,"   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [%d];\n",lut_startAddrBnGroups[idxBnGroup]); 
+            
+            // Loop over CNs
+        for (k=0; k<14; k++)
+        {
+        fprintf(fd,"            p_res = &p_bnProcBufRes[%d];\n", k*cnOffsetInGroup);
+        fprintf(fd,"            p_llrRes = (__m256i*) &llrRes  [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+
+          // Loop over BNs
+        fprintf(fd,"            for (int i=0;i<%d;i++) {\n",M);
+        fprintf(fd,"            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[%d + i]);\n",k*cnOffsetInGroup);
+        fprintf(fd,"            p_res++;\n");
+        fprintf(fd,"            p_llrRes++;\n");
+
+         fprintf(fd,"}\n");
+        
+        }
+    }
+
+
+   // =====================================================================
+
+    
+fprintf(fd,  "// Process group with 15 CNs \n");
+
+
+
+    if (lut_numBnInBnGroups[14] > 0)
+    {
+ // If elements in group move to next address
+        idxBnGroup++;
+
+        // Number of groups of 32 BNs for parallel processing
+        M = (lut_numBnInBnGroups[14]*Z + 31)>>5;
+
+        // Set the offset to each CN within a group in terms of 16 Byte
+        cnOffsetInGroup = (lut_numBnInBnGroups[14]*NR_LDPC_ZMAX)>>5;
+
+        // Set pointers to start of group 2
+        fprintf(fd,"    p_bnProcBuf     = (__m256i*) &bnProcBuf    [%d];\n",lut_startAddrBnGroups[idxBnGroup]);
+        fprintf(fd,"   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [%d];\n",lut_startAddrBnGroups[idxBnGroup]); 
+            
+            // Loop over CNs
+        for (k=0; k<15; k++)
+        {
+        fprintf(fd,"            p_res = &p_bnProcBufRes[%d];\n", k*cnOffsetInGroup);
+        fprintf(fd,"            p_llrRes = (__m256i*) &llrRes  [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+
+          // Loop over BNs
+        fprintf(fd,"            for (int i=0;i<%d;i++) {\n",M);
+        fprintf(fd,"            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[%d + i]);\n",k*cnOffsetInGroup);
+        fprintf(fd,"            p_res++;\n");
+        fprintf(fd,"            p_llrRes++;\n");
+
+         fprintf(fd,"}\n");
+        
+        }
+    }
+
+
+
+   // =====================================================================
+
+    
+fprintf(fd,  "// Process group with 16 CNs \n");
+
+ 
+
+    if (lut_numBnInBnGroups[15] > 0)
+    {
+ // If elements in group move to next address
+        idxBnGroup++;
+
+        // Number of groups of 32 BNs for parallel processing
+        M = (lut_numBnInBnGroups[15]*Z + 31)>>5;
+
+        // Set the offset to each CN within a group in terms of 16 Byte
+        cnOffsetInGroup = (lut_numBnInBnGroups[15]*NR_LDPC_ZMAX)>>5;
+
+        // Set pointers to start of group 2
+        fprintf(fd,"    p_bnProcBuf     = (__m256i*) &bnProcBuf    [%d];\n",lut_startAddrBnGroups[idxBnGroup]);
+        fprintf(fd,"   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [%d];\n",lut_startAddrBnGroups[idxBnGroup]); 
+            
+            // Loop over CNs
+        for (k=0; k<16; k++)
+        {
+        fprintf(fd,"            p_res = &p_bnProcBufRes[%d];\n", k*cnOffsetInGroup);
+        fprintf(fd,"            p_llrRes = (__m256i*) &llrRes  [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+
+          // Loop over BNs
+        fprintf(fd,"            for (int i=0;i<%d;i++) {\n",M);
+        fprintf(fd,"            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[%d + i]);\n",k*cnOffsetInGroup);
+        fprintf(fd,"            p_res++;\n");
+        fprintf(fd,"            p_llrRes++;\n");
+
+         fprintf(fd,"}\n");
+        
+        }
+    }
+
+
+   // =====================================================================
+    // Process group with 17 CNs
+    
+fprintf(fd,  "// Process group with 17 CNs \n");
+
+ // Process group with 17 CNs
+
+    if (lut_numBnInBnGroups[16] > 0)
+    {
+ // If elements in group move to next address
+        idxBnGroup++;
+
+        // Number of groups of 32 BNs for parallel processing
+        M = (lut_numBnInBnGroups[16]*Z + 31)>>5;
+
+        // Set the offset to each CN within a group in terms of 16 Byte
+        cnOffsetInGroup = (lut_numBnInBnGroups[16]*NR_LDPC_ZMAX)>>5;
+
+        // Set pointers to start of group 2
+        fprintf(fd,"    p_bnProcBuf     = (__m256i*) &bnProcBuf    [%d];\n",lut_startAddrBnGroups[idxBnGroup]);
+        fprintf(fd,"   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [%d];\n",lut_startAddrBnGroups[idxBnGroup]); 
+            
+            // Loop over CNs
+        for (k=0; k<17; k++)
+        {
+        fprintf(fd,"            p_res = &p_bnProcBufRes[%d];\n", k*cnOffsetInGroup);
+        fprintf(fd,"            p_llrRes = (__m256i*) &llrRes  [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+
+          // Loop over BNs
+        fprintf(fd,"            for (int i=0;i<%d;i++) {\n",M);
+        fprintf(fd,"            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[%d + i]);\n",k*cnOffsetInGroup);
+        fprintf(fd,"            p_res++;\n");
+        fprintf(fd,"            p_llrRes++;\n");
+
+         fprintf(fd,"}\n");
+        
+        }
+    }
+
+
+   // =====================================================================
+ 
+    
+fprintf(fd,  "// Process group with 18 CNs \n");
+
+ // Process group with 8 CNs
+
+    if (lut_numBnInBnGroups[17] > 0)
+    {
+  // If elements in group move to next address
+        idxBnGroup++;
+
+        // Number of groups of 32 BNs for parallel processing
+        M = (lut_numBnInBnGroups[17]*Z + 31)>>5;
+
+        // Set the offset to each CN within a group in terms of 16 Byte
+        cnOffsetInGroup = (lut_numBnInBnGroups[17]*NR_LDPC_ZMAX)>>5;
+
+        // Set pointers to start of group 2
+        fprintf(fd,"    p_bnProcBuf     = (__m256i*) &bnProcBuf    [%d];\n",lut_startAddrBnGroups[idxBnGroup]);
+        fprintf(fd,"   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [%d];\n",lut_startAddrBnGroups[idxBnGroup]); 
+            
+            // Loop over CNs
+        for (k=0; k<18; k++)
+        {
+        fprintf(fd,"            p_res = &p_bnProcBufRes[%d];\n", k*cnOffsetInGroup);
+        fprintf(fd,"            p_llrRes = (__m256i*) &llrRes  [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+
+          // Loop over BNs
+        fprintf(fd,"            for (int i=0;i<%d;i++) {\n",M);
+        fprintf(fd,"            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[%d + i]);\n",k*cnOffsetInGroup);
+        fprintf(fd,"            p_res++;\n");
+        fprintf(fd,"            p_llrRes++;\n");
+
+         fprintf(fd,"}\n");
+        
+        }
+    }
+
+   // =====================================================================
+ 
+    
+fprintf(fd,  "// Process group with 19 CNs \n");
+
+
+
+    if (lut_numBnInBnGroups[18] > 0)
+    {
+  // If elements in group move to next address
+        idxBnGroup++;
+
+        // Number of groups of 32 BNs for parallel processing
+        M = (lut_numBnInBnGroups[18]*Z + 31)>>5;
+
+        // Set the offset to each CN within a group in terms of 16 Byte
+        cnOffsetInGroup = (lut_numBnInBnGroups[18]*NR_LDPC_ZMAX)>>5;
+
+        // Set pointers to start of group 2
+        fprintf(fd,"    p_bnProcBuf     = (__m256i*) &bnProcBuf    [%d];\n",lut_startAddrBnGroups[idxBnGroup]);
+        fprintf(fd,"   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [%d];\n",lut_startAddrBnGroups[idxBnGroup]); 
+            
+            // Loop over CNs
+        for (k=0; k<19; k++)
+        {
+        fprintf(fd,"            p_res = &p_bnProcBufRes[%d];\n", k*cnOffsetInGroup);
+        fprintf(fd,"            p_llrRes = (__m256i*) &llrRes  [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+
+          // Loop over BNs
+        fprintf(fd,"            for (int i=0;i<%d;i++) {\n",M);
+        fprintf(fd,"            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[%d + i]);\n",k*cnOffsetInGroup);
+        fprintf(fd,"            p_res++;\n");
+        fprintf(fd,"            p_llrRes++;\n");
+
+         fprintf(fd,"}\n");
+        
+        }
+    }
+
+
+   // =====================================================================
+  
+    
+fprintf(fd,  "// Process group with 20 CNs \n");
+
+
+
+    if (lut_numBnInBnGroups[19] > 0)
+    {
+  // If elements in group move to next address
+        idxBnGroup++;
+
+        // Number of groups of 32 BNs for parallel processing
+        M = (lut_numBnInBnGroups[19]*Z + 31)>>5;
+
+        // Set the offset to each CN within a group in terms of 16 Byte
+        cnOffsetInGroup = (lut_numBnInBnGroups[19]*NR_LDPC_ZMAX)>>5;
+
+        // Set pointers to start of group 2
+        fprintf(fd,"    p_bnProcBuf     = (__m256i*) &bnProcBuf    [%d];\n",lut_startAddrBnGroups[idxBnGroup]);
+        fprintf(fd,"   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [%d];\n",lut_startAddrBnGroups[idxBnGroup]); 
+            
+            // Loop over CNs
+        for (k=0; k<20; k++)
+        {
+        fprintf(fd,"            p_res = &p_bnProcBufRes[%d];\n", k*cnOffsetInGroup);
+        fprintf(fd,"            p_llrRes = (__m256i*) &llrRes  [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+
+          // Loop over BNs
+        fprintf(fd,"            for (int i=0;i<%d;i++) {\n",M);
+        fprintf(fd,"            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[%d + i]);\n",k*cnOffsetInGroup);
+        fprintf(fd,"            p_res++;\n");
+        fprintf(fd,"            p_llrRes++;\n");
+
+         fprintf(fd,"}\n");
+        
+        }
+    }
+
+
+
+
+
+    // =====================================================================
+   
+fprintf(fd,  "// Process group with 21 CNs \n");
+
+
+
+ 
+
+    if (lut_numBnInBnGroups[20] > 0)
+    {
+  // If elements in group move to next address
+        idxBnGroup++;
+
+        // Number of groups of 32 BNs for parallel processing
+        M = (lut_numBnInBnGroups[20]*Z + 31)>>5;
+
+        // Set the offset to each CN within a group in terms of 16 Byte
+        cnOffsetInGroup = (lut_numBnInBnGroups[20]*NR_LDPC_ZMAX)>>5;
+
+        // Set pointers to start of group 2
+        fprintf(fd,"    p_bnProcBuf     = (__m256i*) &bnProcBuf    [%d];\n",lut_startAddrBnGroups[idxBnGroup]);
+        fprintf(fd,"   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [%d];\n",lut_startAddrBnGroups[idxBnGroup]); 
+            
+            // Loop over CNs
+        for (k=0; k<21; k++)
+        {
+        fprintf(fd,"            p_res = &p_bnProcBufRes[%d];\n", k*cnOffsetInGroup);
+        fprintf(fd,"            p_llrRes = (__m256i*) &llrRes  [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+
+          // Loop over BNs
+        fprintf(fd,"            for (int i=0;i<%d;i++) {\n",M);
+        fprintf(fd,"            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[%d + i]);\n",k*cnOffsetInGroup);
+        fprintf(fd,"            p_res++;\n");
+        fprintf(fd,"            p_llrRes++;\n");
+
+         fprintf(fd,"}\n");
+        
+        }
+    }
+      // =====================================================================
+
+
+
+fprintf(fd,  "// Process group with 22 CNs \n");
+
+
+    if (lut_numBnInBnGroups[21] > 0)
+    {
+ // If elements in group move to next address
+        idxBnGroup++;
+
+        // Number of groups of 32 BNs for parallel processing
+        M = (lut_numBnInBnGroups[21]*Z + 31)>>5;
+
+        // Set the offset to each CN within a group in terms of 16 Byte
+        cnOffsetInGroup = (lut_numBnInBnGroups[21]*NR_LDPC_ZMAX)>>5;
+
+        // Set pointers to start of group 2
+        fprintf(fd,"    p_bnProcBuf     = (__m256i*) &bnProcBuf    [%d];\n",lut_startAddrBnGroups[idxBnGroup]);
+        fprintf(fd,"   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [%d];\n",lut_startAddrBnGroups[idxBnGroup]); 
+            
+            // Loop over CNs
+        for (k=0; k<22; k++)
+        {
+        fprintf(fd,"            p_res = &p_bnProcBufRes[%d];\n", k*cnOffsetInGroup);
+        fprintf(fd,"            p_llrRes = (__m256i*) &llrRes  [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+
+          // Loop over BNs
+        fprintf(fd,"            for (int i=0;i<%d;i++) {\n",M);
+        fprintf(fd,"            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[%d + i]);\n",k*cnOffsetInGroup);
+        fprintf(fd,"            p_res++;\n");
+        fprintf(fd,"            p_llrRes++;\n");
+
+         fprintf(fd,"}\n");
+        
+        }
+    }
+
+    // =====================================================================
+  
+
+
+fprintf(fd,  "// Process group with <23 CNs \n");
+
+
+
+    if (lut_numBnInBnGroups[22] > 0)
+    {
+  // If elements in group move to next address
+        idxBnGroup++;
+
+        // Number of groups of 32 BNs for parallel processing
+        M = (lut_numBnInBnGroups[22]*Z + 31)>>5;
+
+        // Set the offset to each CN within a group in terms of 16 Byte
+        cnOffsetInGroup = (lut_numBnInBnGroups[22]*NR_LDPC_ZMAX)>>5;
+
+        // Set pointers to start of group 2
+        fprintf(fd,"    p_bnProcBuf     = (__m256i*) &bnProcBuf    [%d];\n",lut_startAddrBnGroups[idxBnGroup]);
+        fprintf(fd,"   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [%d];\n",lut_startAddrBnGroups[idxBnGroup]); 
+            
+            // Loop over CNs
+        for (k=0; k<23; k++)
+        {
+        fprintf(fd,"            p_res = &p_bnProcBufRes[%d];\n", k*cnOffsetInGroup);
+        fprintf(fd,"            p_llrRes = (__m256i*) &llrRes  [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+
+          // Loop over BNs
+        fprintf(fd,"            for (int i=0;i<%d;i++) {\n",M);
+        fprintf(fd,"            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[%d + i]);\n",k*cnOffsetInGroup);
+        fprintf(fd,"            p_res++;\n");
+        fprintf(fd,"            p_llrRes++;\n");
+
+         fprintf(fd,"}\n");
+        
+        }
+    }
+
+
+
+    // =====================================================================
+ 
+
+fprintf(fd,  "// Process group with 24 CNs \n");
+
+ // Process group with 4 CNs
+
+    if (lut_numBnInBnGroups[23] > 0)
+    {
+ // If elements in group move to next address
+        idxBnGroup++;
+
+        // Number of groups of 32 BNs for parallel processing
+        M = (lut_numBnInBnGroups[23]*Z + 31)>>5;
+
+        // Set the offset to each CN within a group in terms of 16 Byte
+        cnOffsetInGroup = (lut_numBnInBnGroups[23]*NR_LDPC_ZMAX)>>5;
+
+        // Set pointers to start of group 2
+        fprintf(fd,"    p_bnProcBuf     = (__m256i*) &bnProcBuf    [%d];\n",lut_startAddrBnGroups[idxBnGroup]);
+        fprintf(fd,"   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [%d];\n",lut_startAddrBnGroups[idxBnGroup]); 
+            
+            // Loop over CNs
+        for (k=0; k<24; k++)
+        {
+        fprintf(fd,"            p_res = &p_bnProcBufRes[%d];\n", k*cnOffsetInGroup);
+        fprintf(fd,"            p_llrRes = (__m256i*) &llrRes  [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+
+          // Loop over BNs
+        fprintf(fd,"            for (int i=0;i<%d;i++) {\n",M);
+        fprintf(fd,"            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[%d + i]);\n",k*cnOffsetInGroup);
+        fprintf(fd,"            p_res++;\n");
+        fprintf(fd,"            p_llrRes++;\n");
+
+         fprintf(fd,"}\n");
+        
+        }
+    }
+
+
+   // =====================================================================
+  
+    
+fprintf(fd,  "// Process group with 25 CNs \n");
+
+
+
+    if (lut_numBnInBnGroups[24] > 0)
+    {
+ // If elements in group move to next address
+        idxBnGroup++;
+
+        // Number of groups of 32 BNs for parallel processing
+        M = (lut_numBnInBnGroups[24]*Z + 31)>>5;
+
+        // Set the offset to each CN within a group in terms of 16 Byte
+        cnOffsetInGroup = (lut_numBnInBnGroups[24]*NR_LDPC_ZMAX)>>5;
+
+        // Set pointers to start of group 2
+        fprintf(fd,"    p_bnProcBuf     = (__m256i*) &bnProcBuf    [%d];\n",lut_startAddrBnGroups[idxBnGroup]);
+        fprintf(fd,"   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [%d];\n",lut_startAddrBnGroups[idxBnGroup]); 
+            
+            // Loop over CNs
+        for (k=0; k<25; k++)
+        {
+        fprintf(fd,"            p_res = &p_bnProcBufRes[%d];\n", k*cnOffsetInGroup);
+        fprintf(fd,"            p_llrRes = (__m256i*) &llrRes  [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+
+          // Loop over BNs
+        fprintf(fd,"            for (int i=0;i<%d;i++) {\n",M);
+        fprintf(fd,"            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[%d + i]);\n",k*cnOffsetInGroup);
+        fprintf(fd,"            p_res++;\n");
+        fprintf(fd,"            p_llrRes++;\n");
+
+         fprintf(fd,"}\n");
+        
+        }
+    }
+
+
+
+   // =====================================================================
+   
+    
+fprintf(fd,  "// Process group with 26 CNs \n");
+
+ 
+
+    if (lut_numBnInBnGroups[25] > 0)
+    {
+ // If elements in group move to next address
+        idxBnGroup++;
+
+        // Number of groups of 32 BNs for parallel processing
+        M = (lut_numBnInBnGroups[25]*Z + 31)>>5;
+
+        // Set the offset to each CN within a group in terms of 16 Byte
+        cnOffsetInGroup = (lut_numBnInBnGroups[25]*NR_LDPC_ZMAX)>>5;
+
+        // Set pointers to start of group 2
+        fprintf(fd,"    p_bnProcBuf     = (__m256i*) &bnProcBuf    [%d];\n",lut_startAddrBnGroups[idxBnGroup]);
+        fprintf(fd,"   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [%d];\n",lut_startAddrBnGroups[idxBnGroup]); 
+            
+            // Loop over CNs
+        for (k=0; k<26; k++)
+        {
+        fprintf(fd,"            p_res = &p_bnProcBufRes[%d];\n", k*cnOffsetInGroup);
+        fprintf(fd,"            p_llrRes = (__m256i*) &llrRes  [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+
+          // Loop over BNs
+        fprintf(fd,"            for (int i=0;i<%d;i++) {\n",M);
+        fprintf(fd,"            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[%d + i]);\n",k*cnOffsetInGroup);
+        fprintf(fd,"            p_res++;\n");
+        fprintf(fd,"            p_llrRes++;\n");
+
+         fprintf(fd,"}\n");
+        
+        }
+    }
+
+
+   // =====================================================================
+
+    
+fprintf(fd,  "// Process group with 27 CNs \n");
+
+ // Process group with 17 CNs
+
+    if (lut_numBnInBnGroups[26] > 0)
+    {
+ // If elements in group move to next address
+        idxBnGroup++;
+
+        // Number of groups of 32 BNs for parallel processing
+        M = (lut_numBnInBnGroups[26]*Z + 31)>>5;
+
+        // Set the offset to each CN within a group in terms of 16 Byte
+        cnOffsetInGroup = (lut_numBnInBnGroups[26]*NR_LDPC_ZMAX)>>5;
+
+        // Set pointers to start of group 2
+        fprintf(fd,"    p_bnProcBuf     = (__m256i*) &bnProcBuf    [%d];\n",lut_startAddrBnGroups[idxBnGroup]);
+        fprintf(fd,"   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [%d];\n",lut_startAddrBnGroups[idxBnGroup]); 
+            
+            // Loop over CNs
+        for (k=0; k<27; k++)
+        {
+        fprintf(fd,"            p_res = &p_bnProcBufRes[%d];\n", k*cnOffsetInGroup);
+        fprintf(fd,"            p_llrRes = (__m256i*) &llrRes  [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+
+          // Loop over BNs
+        fprintf(fd,"            for (int i=0;i<%d;i++) {\n",M);
+        fprintf(fd,"            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[%d + i]);\n",k*cnOffsetInGroup);
+        fprintf(fd,"            p_res++;\n");
+        fprintf(fd,"            p_llrRes++;\n");
+
+         fprintf(fd,"}\n");
+        
+        }
+    }
+
+
+   // =====================================================================
+    
+    
+fprintf(fd,  "// Process group with 28 CNs \n");
+
+ // Process group with 8 CNs
+
+    if (lut_numBnInBnGroups[27] > 0)
+    {
+ // If elements in group move to next address
+        idxBnGroup++;
+
+        // Number of groups of 32 BNs for parallel processing
+        M = (lut_numBnInBnGroups[27]*Z + 31)>>5;
+
+        // Set the offset to each CN within a group in terms of 16 Byte
+        cnOffsetInGroup = (lut_numBnInBnGroups[27]*NR_LDPC_ZMAX)>>5;
+
+        // Set pointers to start of group 2
+        fprintf(fd,"    p_bnProcBuf     = (__m256i*) &bnProcBuf    [%d];\n",lut_startAddrBnGroups[idxBnGroup]);
+        fprintf(fd,"   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [%d];\n",lut_startAddrBnGroups[idxBnGroup]); 
+            
+            // Loop over CNs
+        for (k=0; k<28; k++)
+        {
+        fprintf(fd,"            p_res = &p_bnProcBufRes[%d];\n", k*cnOffsetInGroup);
+        fprintf(fd,"            p_llrRes = (__m256i*) &llrRes  [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+
+          // Loop over BNs
+        fprintf(fd,"            for (int i=0;i<%d;i++) {\n",M);
+        fprintf(fd,"            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[%d + i]);\n",k*cnOffsetInGroup);
+        fprintf(fd,"            p_res++;\n");
+        fprintf(fd,"            p_llrRes++;\n");
+
+         fprintf(fd,"}\n");
+        
+        }
+    }
+
+   // =====================================================================
+  
+fprintf(fd,  "// Process group with 29 CNs \n");
+
+ // Process group with 9 CNs
+
+    if (lut_numBnInBnGroups[28] > 0)
+    {
+ // If elements in group move to next address
+        idxBnGroup++;
+
+        // Number of groups of 32 BNs for parallel processing
+        M = (lut_numBnInBnGroups[28]*Z + 31)>>5;
+
+        // Set the offset to each CN within a group in terms of 16 Byte
+        cnOffsetInGroup = (lut_numBnInBnGroups[28]*NR_LDPC_ZMAX)>>5;
+
+        // Set pointers to start of group 2
+        fprintf(fd,"    p_bnProcBuf     = (__m256i*) &bnProcBuf    [%d];\n",lut_startAddrBnGroups[idxBnGroup]);
+        fprintf(fd,"   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [%d];\n",lut_startAddrBnGroups[idxBnGroup]); 
+            
+            // Loop over CNs
+        for (k=0; k<29; k++)
+        {
+        fprintf(fd,"            p_res = &p_bnProcBufRes[%d];\n", k*cnOffsetInGroup);
+        fprintf(fd,"            p_llrRes = (__m256i*) &llrRes  [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+
+          // Loop over BNs
+        fprintf(fd,"            for (int i=0;i<%d;i++) {\n",M);
+        fprintf(fd,"            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[%d + i]);\n",k*cnOffsetInGroup);
+        fprintf(fd,"            p_res++;\n");
+        fprintf(fd,"            p_llrRes++;\n");
+
+         fprintf(fd,"}\n");
+        
+        }
+    }
+
+
+   // =====================================================================
+
+fprintf(fd,  "// Process group with 30 CNs \n");
+
+ // Process group with 20 CNs
+
+    if (lut_numBnInBnGroups[29] > 0)
+    {
+ // If elements in group move to next address
+        idxBnGroup++;
+
+        // Number of groups of 32 BNs for parallel processing
+        M = (lut_numBnInBnGroups[29]*Z + 31)>>5;
+
+        // Set the offset to each CN within a group in terms of 16 Byte
+        cnOffsetInGroup = (lut_numBnInBnGroups[29]*NR_LDPC_ZMAX)>>5;
+
+        // Set pointers to start of group 2
+        fprintf(fd,"    p_bnProcBuf     = (__m256i*) &bnProcBuf    [%d];\n",lut_startAddrBnGroups[idxBnGroup]);
+        fprintf(fd,"   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [%d];\n",lut_startAddrBnGroups[idxBnGroup]); 
+            
+            // Loop over CNs
+        for (k=0; k<30; k++)
+        {
+        fprintf(fd,"            p_res = &p_bnProcBufRes[%d];\n", k*cnOffsetInGroup);
+        fprintf(fd,"            p_llrRes = (__m256i*) &llrRes  [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+
+          // Loop over BNs
+        fprintf(fd,"            for (int i=0;i<%d;i++) {\n",M);
+        fprintf(fd,"            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[%d + i]);\n",k*cnOffsetInGroup);
+        fprintf(fd,"            p_res++;\n");
+        fprintf(fd,"            p_llrRes++;\n");
+
+         fprintf(fd,"}\n");
+        
+        }
+    }
+
+    fprintf(fd,"}\n");
+  fclose(fd);
+}//end of the function  nrLDPC_bnProc_BG1
+
+
+
+
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_bnProc/bnProc_gen_BG1_avx2.c.1 b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_bnProc/bnProc_gen_BG1_avx2.c.1
new file mode 100644
index 0000000000..7f5110072d
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_bnProc/bnProc_gen_BG1_avx2.c.1
@@ -0,0 +1,1235 @@
+
+
+#include <stdint.h>
+#include <immintrin.h>
+#include "../../nrLDPCdecoder_defs.h"
+#include "../../nrLDPC_types.h"
+#include "../../nrLDPC_bnProc.h"
+#include "../../nrLDPC_cnProc.h"
+#include "../../nrLDPC_init.h"
+
+void nrLDPC_bnProc_BG1_generator_AVX2(uint16_t Z,int R)
+{
+  const char *ratestr[3]={"13","23","89"};
+
+  if (R<0 || R>2) {printf("Illegal R %d\n",R); abort();}
+
+
+ // system("mkdir -p ../ldpc_gen_files");
+
+  char fname[50];
+  sprintf(fname,"../ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z%d_R%s_AVX2.c",Z,ratestr[R]);
+  FILE *fd=fopen(fname,"w");
+  if (fd == NULL) {printf("Cannot create \n");abort();}
+
+  fprintf(fd,"#include <stdint.h>\n");
+  fprintf(fd,"#include <immintrin.h>\n");
+
+    
+    fprintf(fd,"void nrLDPC_bnProc_BG1_Z%d_R%s_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes,  int8_t* llrRes ) {\n",Z, ratestr[R]);
+    const uint8_t*  lut_numBnInBnGroups;
+    const uint32_t* lut_startAddrBnGroups;
+    const uint16_t* lut_startAddrBnGroupsLlr;
+    if (R==0) {
+
+
+      lut_numBnInBnGroups =  lut_numBnInBnGroups_BG1_R13;
+      lut_startAddrBnGroups = lut_startAddrBnGroups_BG1_R13;
+      lut_startAddrBnGroupsLlr = lut_startAddrBnGroupsLlr_BG1_R13;
+
+    }
+    else if (R==1){
+
+      lut_numBnInBnGroups =  lut_numBnInBnGroups_BG1_R23;
+      lut_startAddrBnGroups = lut_startAddrBnGroups_BG1_R23;
+      lut_startAddrBnGroupsLlr = lut_startAddrBnGroupsLlr_BG1_R23;
+    }
+    else if (R==2) {
+
+      lut_numBnInBnGroups = lut_numBnInBnGroups_BG1_R89;
+      lut_startAddrBnGroups = lut_startAddrBnGroups_BG1_R89;
+      lut_startAddrBnGroupsLlr = lut_startAddrBnGroupsLlr_BG1_R89;
+    }
+  else { printf("aborting, illegal R %d\n",R); fclose(fd);abort();}
+
+
+    uint32_t M;
+    //uint32_t M32rem;
+   // uint32_t i;
+    uint32_t k;
+    // Offset to each bit within a group in terms of 32 Byte
+    uint32_t cnOffsetInGroup;
+    uint8_t idxBnGroup = 0;
+
+
+    
+    fprintf(fd,"        __m256i* p_bnProcBuf; \n");
+    fprintf(fd,"        __m256i* p_bnProcBufRes; \n");
+    fprintf(fd,"        __m256i* p_llrRes; \n");
+    fprintf(fd,"        __m256i* p_res; \n");
+
+
+
+// =====================================================================
+    // Process group with 1 CN
+    // Already done in bnProcBufPc
+
+    // =====================================================================
+
+fprintf(fd,  "// Process group with 2 CNs \n");
+
+    if (lut_numBnInBnGroups[1] > 0)
+    {
+ // If elements in group move to next address
+        idxBnGroup++;
+
+        // Number of groups of 32 BNs for parallel processing
+        M = (lut_numBnInBnGroups[1]*Z + 31)>>5;
+
+        // Set the offset to each CN within a group in terms of 16 Byte
+        cnOffsetInGroup = (lut_numBnInBnGroups[1]*NR_LDPC_ZMAX)>>5;
+
+        // Set pointers to start of group 2
+        fprintf(fd,"    p_bnProcBuf     = (__m256i*) &bnProcBuf    [%d];\n",lut_startAddrBnGroups[idxBnGroup]);
+        fprintf(fd,"   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [%d];\n",lut_startAddrBnGroups[idxBnGroup]); 
+            
+            // Loop over CNs
+        for (k=0; k<2; k++)
+        {
+        fprintf(fd,"            p_res = &p_bnProcBufRes[%d];\n", k*cnOffsetInGroup);
+        fprintf(fd,"            p_llrRes = (__m256i*) &llrRes  [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+
+          // Loop over BNs
+        fprintf(fd,"            for (int i=0;i<%d;i++) {\n",M);
+        fprintf(fd,"            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[%d + i]);\n",k*cnOffsetInGroup);
+        fprintf(fd,"            p_res++;\n");
+        fprintf(fd,"            p_llrRes++;\n");
+
+         fprintf(fd,"}\n");
+        
+        }
+
+        
+       
+    }
+
+    // =====================================================================
+
+
+fprintf(fd,  "// Process group with 3 CNs \n");
+
+
+
+    if (lut_numBnInBnGroups[2] > 0)
+    {
+ // If elements in group move to next address
+        idxBnGroup++;
+
+        // Number of groups of 32 BNs for parallel processing
+        M = (lut_numBnInBnGroups[2]*Z + 31)>>5;
+
+        // Set the offset to each CN within a group in terms of 16 Byte
+        cnOffsetInGroup = (lut_numBnInBnGroups[2]*NR_LDPC_ZMAX)>>5;
+
+        // Set pointers to start of group 2
+        fprintf(fd,"    p_bnProcBuf     = (__m256i*) &bnProcBuf    [%d];\n",lut_startAddrBnGroups[idxBnGroup]);
+        fprintf(fd,"   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [%d];\n",lut_startAddrBnGroups[idxBnGroup]); 
+            
+        for (k=0; k<3; k++)
+        {
+        fprintf(fd,"            p_res = &p_bnProcBufRes[%d];\n", k*cnOffsetInGroup);
+        fprintf(fd,"            p_llrRes = (__m256i*) &llrRes  [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+
+          // Loop over BNs
+        fprintf(fd,"            for (int i=0;i<%d;i++) {\n",M);
+        fprintf(fd,"            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[%d + i]);\n",k*cnOffsetInGroup);
+        fprintf(fd,"            p_res++;\n");
+        fprintf(fd,"            p_llrRes++;\n");
+
+         fprintf(fd,"}\n");
+        }
+    }
+
+
+
+    // =====================================================================
+   
+
+fprintf(fd,  "// Process group with 4 CNs \n");
+
+ 
+
+    if (lut_numBnInBnGroups[3] > 0)
+    {
+        // If elements in group move to next address
+        idxBnGroup++;
+
+        // Number of groups of 32 BNs for parallel processing
+        M = (lut_numBnInBnGroups[3]*Z + 31)>>5;
+
+        // Set the offset to each CN within a group in terms of 16 Byte
+        cnOffsetInGroup = (lut_numBnInBnGroups[3]*NR_LDPC_ZMAX)>>5;
+
+        // Set pointers to start of group 2
+        fprintf(fd,"    p_bnProcBuf     = (__m256i*) &bnProcBuf    [%d];\n",lut_startAddrBnGroups[idxBnGroup]);
+        fprintf(fd,"   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [%d];\n",lut_startAddrBnGroups[idxBnGroup]); 
+            
+        for (k=0; k<4; k++)
+        {
+        fprintf(fd,"            p_res = &p_bnProcBufRes[%d];\n", k*cnOffsetInGroup);
+        fprintf(fd,"            p_llrRes = (__m256i*) &llrRes  [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+
+          // Loop over BNs
+        fprintf(fd,"            for (int i=0;i<%d;i++) {\n",M);
+        fprintf(fd,"            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[%d + i]);\n",k*cnOffsetInGroup);
+        fprintf(fd,"            p_res++;\n");
+        fprintf(fd,"            p_llrRes++;\n");
+
+         fprintf(fd,"}\n");
+        }
+    }
+
+
+   // =====================================================================
+
+    
+    fprintf(fd,  "// Process group with 5 CNs \n");
+
+
+
+    if (lut_numBnInBnGroups[4] > 0)
+    {
+    // If elements in group move to next address
+        idxBnGroup++;
+
+        // Number of groups of 32 BNs for parallel processing
+        M = (lut_numBnInBnGroups[4]*Z + 31)>>5;
+
+        // Set the offset to each CN within a group in terms of 16 Byte
+        cnOffsetInGroup = (lut_numBnInBnGroups[4]*NR_LDPC_ZMAX)>>5;
+
+        // Set pointers to start of group 2
+        fprintf(fd,"    p_bnProcBuf     = (__m256i*) &bnProcBuf    [%d];\n",lut_startAddrBnGroups[idxBnGroup]);
+        fprintf(fd,"   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [%d];\n",lut_startAddrBnGroups[idxBnGroup]); 
+            
+            // Loop over CNs
+        for (k=0; k<5; k++)
+        {
+        fprintf(fd,"            p_res = &p_bnProcBufRes[%d];\n", k*cnOffsetInGroup);
+        fprintf(fd,"            p_llrRes = (__m256i*) &llrRes  [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+
+          // Loop over BNs
+        fprintf(fd,"            for (int i=0;i<%d;i++) {\n",M);
+        fprintf(fd,"            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[%d + i]);\n",k*cnOffsetInGroup);
+        fprintf(fd,"            p_res++;\n");
+        fprintf(fd,"            p_llrRes++;\n");
+
+         fprintf(fd,"}\n");
+        
+        }
+    }
+
+
+
+   // =====================================================================
+ 
+    
+fprintf(fd,  "// Process group with 6 CNs \n");
+
+ // Process group with 6 CNs
+
+    if (lut_numBnInBnGroups[5] > 0)
+    {
+  // If elements in group move to next address
+        idxBnGroup++;
+
+        // Number of groups of 32 BNs for parallel processing
+        M = (lut_numBnInBnGroups[5]*Z + 31)>>5;
+
+        // Set the offset to each CN within a group in terms of 16 Byte
+        cnOffsetInGroup = (lut_numBnInBnGroups[5]*NR_LDPC_ZMAX)>>5;
+
+        // Set pointers to start of group 2
+        fprintf(fd,"    p_bnProcBuf     = (__m256i*) &bnProcBuf    [%d];\n",lut_startAddrBnGroups[idxBnGroup]);
+        fprintf(fd,"   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [%d];\n",lut_startAddrBnGroups[idxBnGroup]); 
+            
+            // Loop over CNs
+        for (k=0; k<6; k++)
+        {
+        fprintf(fd,"            p_res = &p_bnProcBufRes[%d];\n", k*cnOffsetInGroup);
+        fprintf(fd,"            p_llrRes = (__m256i*) &llrRes  [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+
+          // Loop over BNs
+        fprintf(fd,"            for (int i=0;i<%d;i++) {\n",M);
+        fprintf(fd,"            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[%d + i]);\n",k*cnOffsetInGroup);
+        fprintf(fd,"            p_res++;\n");
+        fprintf(fd,"            p_llrRes++;\n");
+
+         fprintf(fd,"}\n");
+        
+        }
+    }
+
+
+   // =====================================================================
+
+    
+fprintf(fd,  "// Process group with 7 CNs \n");
+
+ // Process group with 7 CNs
+
+    if (lut_numBnInBnGroups[6] > 0)
+    {
+  // If elements in group move to next address
+        idxBnGroup++;
+
+        // Number of groups of 32 BNs for parallel processing
+        M = (lut_numBnInBnGroups[6]*Z + 31)>>5;
+
+        // Set the offset to each CN within a group in terms of 16 Byte
+        cnOffsetInGroup = (lut_numBnInBnGroups[6]*NR_LDPC_ZMAX)>>5;
+
+        // Set pointers to start of group 2
+        fprintf(fd,"    p_bnProcBuf     = (__m256i*) &bnProcBuf    [%d];\n",lut_startAddrBnGroups[idxBnGroup]);
+        fprintf(fd,"   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [%d];\n",lut_startAddrBnGroups[idxBnGroup]); 
+            
+            // Loop over CNs
+        for (k=0; k<7; k++)
+        {
+        fprintf(fd,"            p_res = &p_bnProcBufRes[%d];\n", k*cnOffsetInGroup);
+        fprintf(fd,"            p_llrRes = (__m256i*) &llrRes  [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+
+          // Loop over BNs
+        fprintf(fd,"            for (int i=0;i<%d;i++) {\n",M);
+        fprintf(fd,"            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[%d + i]);\n",k*cnOffsetInGroup);
+        fprintf(fd,"            p_res++;\n");
+        fprintf(fd,"            p_llrRes++;\n");
+
+         fprintf(fd,"}\n");
+        
+        }
+    }
+
+
+   // =====================================================================
+ 
+    
+fprintf(fd,  "// Process group with 8 CNs \n");
+
+ // Process group with 8 CNs
+
+    if (lut_numBnInBnGroups[7] > 0)
+    {
+ // If elements in group move to next address
+        idxBnGroup++;
+
+        // Number of groups of 32 BNs for parallel processing
+        M = (lut_numBnInBnGroups[7]*Z + 31)>>5;
+
+        // Set the offset to each CN within a group in terms of 16 Byte
+        cnOffsetInGroup = (lut_numBnInBnGroups[7]*NR_LDPC_ZMAX)>>5;
+
+        // Set pointers to start of group 2
+        fprintf(fd,"    p_bnProcBuf     = (__m256i*) &bnProcBuf    [%d];\n",lut_startAddrBnGroups[idxBnGroup]);
+        fprintf(fd,"   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [%d];\n",lut_startAddrBnGroups[idxBnGroup]); 
+            
+            // Loop over CNs
+        for (k=0; k<8; k++)
+        {
+        fprintf(fd,"            p_res = &p_bnProcBufRes[%d];\n", k*cnOffsetInGroup);
+        fprintf(fd,"            p_llrRes = (__m256i*) &llrRes  [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+
+          // Loop over BNs
+        fprintf(fd,"            for (int i=0;i<%d;i++) {\n",M);
+        fprintf(fd,"            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[%d + i]);\n",k*cnOffsetInGroup);
+        fprintf(fd,"            p_res++;\n");
+        fprintf(fd,"            p_llrRes++;\n");
+
+         fprintf(fd,"}\n");
+        
+        }
+    }
+
+   // =====================================================================
+
+    
+fprintf(fd,  "// Process group with 9 CNs \n");
+
+ // Process group with 9 CNs
+
+    if (lut_numBnInBnGroups[8] > 0)
+    {
+  // If elements in group move to next address
+        idxBnGroup++;
+
+        // Number of groups of 32 BNs for parallel processing
+        M = (lut_numBnInBnGroups[8]*Z + 31)>>5;
+
+        // Set the offset to each CN within a group in terms of 16 Byte
+        cnOffsetInGroup = (lut_numBnInBnGroups[8]*NR_LDPC_ZMAX)>>5;
+
+        // Set pointers to start of group 2
+        fprintf(fd,"    p_bnProcBuf     = (__m256i*) &bnProcBuf    [%d];\n",lut_startAddrBnGroups[idxBnGroup]);
+        fprintf(fd,"   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [%d];\n",lut_startAddrBnGroups[idxBnGroup]); 
+            
+            // Loop over CNs
+        for (k=0; k<9; k++)
+        {
+        fprintf(fd,"            p_res = &p_bnProcBufRes[%d];\n", k*cnOffsetInGroup);
+        fprintf(fd,"            p_llrRes = (__m256i*) &llrRes  [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+
+          // Loop over BNs
+        fprintf(fd,"            for (int i=0;i<%d;i++) {\n",M);
+        fprintf(fd,"            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[%d + i]);\n",k*cnOffsetInGroup);
+        fprintf(fd,"            p_res++;\n");
+        fprintf(fd,"            p_llrRes++;\n");
+
+         fprintf(fd,"}\n");
+        
+        }
+    }
+
+
+   // =====================================================================
+
+fprintf(fd,  "// Process group with 10 CNs \n");
+
+ // Process group with 10 CNs
+
+    if (lut_numBnInBnGroups[9] > 0)
+    {
+ // If elements in group move to next address
+        idxBnGroup++;
+
+        // Number of groups of 32 BNs for parallel processing
+        M = (lut_numBnInBnGroups[9]*Z + 31)>>5;
+
+        // Set the offset to each CN within a group in terms of 16 Byte
+        cnOffsetInGroup = (lut_numBnInBnGroups[9]*NR_LDPC_ZMAX)>>5;
+
+        // Set pointers to start of group 2
+        fprintf(fd,"    p_bnProcBuf     = (__m256i*) &bnProcBuf    [%d];\n",lut_startAddrBnGroups[idxBnGroup]);
+        fprintf(fd,"   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [%d];\n",lut_startAddrBnGroups[idxBnGroup]); 
+            
+            // Loop over CNs
+        for (k=0; k<10; k++)
+        {
+        fprintf(fd,"            p_res = &p_bnProcBufRes[%d];\n", k*cnOffsetInGroup);
+        fprintf(fd,"            p_llrRes = (__m256i*) &llrRes  [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+
+          // Loop over BNs
+        fprintf(fd,"            for (int i=0;i<%d;i++) {\n",M);
+        fprintf(fd,"            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[%d + i]);\n",k*cnOffsetInGroup);
+        fprintf(fd,"            p_res++;\n");
+        fprintf(fd,"            p_llrRes++;\n");
+
+         fprintf(fd,"}\n");
+        
+        }
+    }
+
+
+
+    // =====================================================================
+   
+fprintf(fd,  "// Process group with 11 CNs \n");
+
+    if (lut_numBnInBnGroups[10] > 0)
+    {
+  // If elements in group move to next address
+        idxBnGroup++;
+
+        // Number of groups of 32 BNs for parallel processing
+        M = (lut_numBnInBnGroups[10]*Z + 31)>>5;
+
+        // Set the offset to each CN within a group in terms of 16 Byte
+        cnOffsetInGroup = (lut_numBnInBnGroups[10]*NR_LDPC_ZMAX)>>5;
+
+        // Set pointers to start of group 2
+        fprintf(fd,"    p_bnProcBuf     = (__m256i*) &bnProcBuf    [%d];\n",lut_startAddrBnGroups[idxBnGroup]);
+        fprintf(fd,"   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [%d];\n",lut_startAddrBnGroups[idxBnGroup]); 
+            
+            // Loop over CNs
+        for (k=0; k<11; k++)
+        {
+        fprintf(fd,"            p_res = &p_bnProcBufRes[%d];\n", k*cnOffsetInGroup);
+        fprintf(fd,"            p_llrRes = (__m256i*) &llrRes  [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+
+          // Loop over BNs
+        fprintf(fd,"            for (int i=0;i<%d;i++) {\n",M);
+        fprintf(fd,"            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[%d + i]);\n",k*cnOffsetInGroup);
+        fprintf(fd,"            p_res++;\n");
+        fprintf(fd,"            p_llrRes++;\n");
+
+         fprintf(fd,"}\n");
+        
+        }
+    }
+      // =====================================================================
+
+
+
+fprintf(fd,  "// Process group with 12 CNs \n");
+
+
+    if (lut_numBnInBnGroups[11] > 0)
+    {
+  // If elements in group move to next address
+        idxBnGroup++;
+
+        // Number of groups of 32 BNs for parallel processing
+        M = (lut_numBnInBnGroups[11]*Z + 31)>>5;
+
+        // Set the offset to each CN within a group in terms of 16 Byte
+        cnOffsetInGroup = (lut_numBnInBnGroups[11]*NR_LDPC_ZMAX)>>5;
+
+        // Set pointers to start of group 2
+        fprintf(fd,"    p_bnProcBuf     = (__m256i*) &bnProcBuf    [%d];\n",lut_startAddrBnGroups[idxBnGroup]);
+        fprintf(fd,"   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [%d];\n",lut_startAddrBnGroups[idxBnGroup]); 
+            
+            // Loop over CNs
+        for (k=0; k<12; k++)
+        {
+        fprintf(fd,"            p_res = &p_bnProcBufRes[%d];\n", k*cnOffsetInGroup);
+        fprintf(fd,"            p_llrRes = (__m256i*) &llrRes  [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+
+          // Loop over BNs
+        fprintf(fd,"            for (int i=0;i<%d;i++) {\n",M);
+        fprintf(fd,"            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[%d + i]);\n",k*cnOffsetInGroup);
+        fprintf(fd,"            p_res++;\n");
+        fprintf(fd,"            p_llrRes++;\n");
+
+         fprintf(fd,"}\n");
+        
+        }
+    }
+
+    // =====================================================================
+
+
+
+fprintf(fd,  "// Process group with 13 CNs \n");
+
+
+
+    if (lut_numBnInBnGroups[12] > 0)
+    {
+  // If elements in group move to next address
+        idxBnGroup++;
+
+        // Number of groups of 32 BNs for parallel processing
+        M = (lut_numBnInBnGroups[12]*Z + 31)>>5;
+
+        // Set the offset to each CN within a group in terms of 16 Byte
+        cnOffsetInGroup = (lut_numBnInBnGroups[12]*NR_LDPC_ZMAX)>>5;
+
+        // Set pointers to start of group 2
+        fprintf(fd,"    p_bnProcBuf     = (__m256i*) &bnProcBuf    [%d];\n",lut_startAddrBnGroups[idxBnGroup]);
+        fprintf(fd,"   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [%d];\n",lut_startAddrBnGroups[idxBnGroup]); 
+            
+            // Loop over CNs
+        for (k=0; k<1; k++)
+        {
+        fprintf(fd,"            p_res = &p_bnProcBufRes[%d];\n", k*cnOffsetInGroup);
+        fprintf(fd,"            p_llrRes = (__m256i*) &llrRes  [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+
+          // Loop over BNs
+        fprintf(fd,"            for (int i=0;i<%d;i++) {\n",M);
+        fprintf(fd,"            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[%d + i]);\n",k*cnOffsetInGroup);
+        fprintf(fd,"            p_res++;\n");
+        fprintf(fd,"            p_llrRes++;\n");
+
+         fprintf(fd,"}\n");
+        
+        }
+    }
+
+
+
+    // =====================================================================
+   
+
+fprintf(fd,  "// Process group with 14 CNs \n");
+
+
+
+    if (lut_numBnInBnGroups[13] > 0)
+    {
+  // If elements in group move to next address
+        idxBnGroup++;
+
+        // Number of groups of 32 BNs for parallel processing
+        M = (lut_numBnInBnGroups[13]*Z + 31)>>5;
+
+        // Set the offset to each CN within a group in terms of 16 Byte
+        cnOffsetInGroup = (lut_numBnInBnGroups[13]*NR_LDPC_ZMAX)>>5;
+
+        // Set pointers to start of group 2
+        fprintf(fd,"    p_bnProcBuf     = (__m256i*) &bnProcBuf    [%d];\n",lut_startAddrBnGroups[idxBnGroup]);
+        fprintf(fd,"   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [%d];\n",lut_startAddrBnGroups[idxBnGroup]); 
+            
+            // Loop over CNs
+        for (k=0; k<14; k++)
+        {
+        fprintf(fd,"            p_res = &p_bnProcBufRes[%d];\n", k*cnOffsetInGroup);
+        fprintf(fd,"            p_llrRes = (__m256i*) &llrRes  [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+
+          // Loop over BNs
+        fprintf(fd,"            for (int i=0;i<%d;i++) {\n",M);
+        fprintf(fd,"            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[%d + i]);\n",k*cnOffsetInGroup);
+        fprintf(fd,"            p_res++;\n");
+        fprintf(fd,"            p_llrRes++;\n");
+
+         fprintf(fd,"}\n");
+        
+        }
+    }
+
+
+   // =====================================================================
+
+    
+fprintf(fd,  "// Process group with 15 CNs \n");
+
+
+
+    if (lut_numBnInBnGroups[14] > 0)
+    {
+ // If elements in group move to next address
+        idxBnGroup++;
+
+        // Number of groups of 32 BNs for parallel processing
+        M = (lut_numBnInBnGroups[14]*Z + 31)>>5;
+
+        // Set the offset to each CN within a group in terms of 16 Byte
+        cnOffsetInGroup = (lut_numBnInBnGroups[14]*NR_LDPC_ZMAX)>>5;
+
+        // Set pointers to start of group 2
+        fprintf(fd,"    p_bnProcBuf     = (__m256i*) &bnProcBuf    [%d];\n",lut_startAddrBnGroups[idxBnGroup]);
+        fprintf(fd,"   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [%d];\n",lut_startAddrBnGroups[idxBnGroup]); 
+            
+            // Loop over CNs
+        for (k=0; k<15; k++)
+        {
+        fprintf(fd,"            p_res = &p_bnProcBufRes[%d];\n", k*cnOffsetInGroup);
+        fprintf(fd,"            p_llrRes = (__m256i*) &llrRes  [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+
+          // Loop over BNs
+        fprintf(fd,"            for (int i=0;i<%d;i++) {\n",M);
+        fprintf(fd,"            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[%d + i]);\n",k*cnOffsetInGroup);
+        fprintf(fd,"            p_res++;\n");
+        fprintf(fd,"            p_llrRes++;\n");
+
+         fprintf(fd,"}\n");
+        
+        }
+    }
+
+
+
+   // =====================================================================
+
+    
+fprintf(fd,  "// Process group with 16 CNs \n");
+
+ 
+
+    if (lut_numBnInBnGroups[15] > 0)
+    {
+ // If elements in group move to next address
+        idxBnGroup++;
+
+        // Number of groups of 32 BNs for parallel processing
+        M = (lut_numBnInBnGroups[15]*Z + 31)>>5;
+
+        // Set the offset to each CN within a group in terms of 16 Byte
+        cnOffsetInGroup = (lut_numBnInBnGroups[15]*NR_LDPC_ZMAX)>>5;
+
+        // Set pointers to start of group 2
+        fprintf(fd,"    p_bnProcBuf     = (__m256i*) &bnProcBuf    [%d];\n",lut_startAddrBnGroups[idxBnGroup]);
+        fprintf(fd,"   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [%d];\n",lut_startAddrBnGroups[idxBnGroup]); 
+            
+            // Loop over CNs
+        for (k=0; k<16; k++)
+        {
+        fprintf(fd,"            p_res = &p_bnProcBufRes[%d];\n", k*cnOffsetInGroup);
+        fprintf(fd,"            p_llrRes = (__m256i*) &llrRes  [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+
+          // Loop over BNs
+        fprintf(fd,"            for (int i=0;i<%d;i++) {\n",M);
+        fprintf(fd,"            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[%d + i]);\n",k*cnOffsetInGroup);
+        fprintf(fd,"            p_res++;\n");
+        fprintf(fd,"            p_llrRes++;\n");
+
+         fprintf(fd,"}\n");
+        
+        }
+    }
+
+
+   // =====================================================================
+    // Process group with 17 CNs
+    
+fprintf(fd,  "// Process group with 17 CNs \n");
+
+ // Process group with 17 CNs
+
+    if (lut_numBnInBnGroups[16] > 0)
+    {
+ // If elements in group move to next address
+        idxBnGroup++;
+
+        // Number of groups of 32 BNs for parallel processing
+        M = (lut_numBnInBnGroups[16]*Z + 31)>>5;
+
+        // Set the offset to each CN within a group in terms of 16 Byte
+        cnOffsetInGroup = (lut_numBnInBnGroups[16]*NR_LDPC_ZMAX)>>5;
+
+        // Set pointers to start of group 2
+        fprintf(fd,"    p_bnProcBuf     = (__m256i*) &bnProcBuf    [%d];\n",lut_startAddrBnGroups[idxBnGroup]);
+        fprintf(fd,"   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [%d];\n",lut_startAddrBnGroups[idxBnGroup]); 
+            
+            // Loop over CNs
+        for (k=0; k<17; k++)
+        {
+        fprintf(fd,"            p_res = &p_bnProcBufRes[%d];\n", k*cnOffsetInGroup);
+        fprintf(fd,"            p_llrRes = (__m256i*) &llrRes  [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+
+          // Loop over BNs
+        fprintf(fd,"            for (int i=0;i<%d;i++) {\n",M);
+        fprintf(fd,"            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[%d + i]);\n",k*cnOffsetInGroup);
+        fprintf(fd,"            p_res++;\n");
+        fprintf(fd,"            p_llrRes++;\n");
+
+         fprintf(fd,"}\n");
+        
+        }
+    }
+
+
+   // =====================================================================
+ 
+    
+fprintf(fd,  "// Process group with 18 CNs \n");
+
+ // Process group with 8 CNs
+
+    if (lut_numBnInBnGroups[17] > 0)
+    {
+  // If elements in group move to next address
+        idxBnGroup++;
+
+        // Number of groups of 32 BNs for parallel processing
+        M = (lut_numBnInBnGroups[17]*Z + 31)>>5;
+
+        // Set the offset to each CN within a group in terms of 16 Byte
+        cnOffsetInGroup = (lut_numBnInBnGroups[17]*NR_LDPC_ZMAX)>>5;
+
+        // Set pointers to start of group 2
+        fprintf(fd,"    p_bnProcBuf     = (__m256i*) &bnProcBuf    [%d];\n",lut_startAddrBnGroups[idxBnGroup]);
+        fprintf(fd,"   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [%d];\n",lut_startAddrBnGroups[idxBnGroup]); 
+            
+            // Loop over CNs
+        for (k=0; k<18; k++)
+        {
+        fprintf(fd,"            p_res = &p_bnProcBufRes[%d];\n", k*cnOffsetInGroup);
+        fprintf(fd,"            p_llrRes = (__m256i*) &llrRes  [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+
+          // Loop over BNs
+        fprintf(fd,"            for (int i=0;i<%d;i++) {\n",M);
+        fprintf(fd,"            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[%d + i]);\n",k*cnOffsetInGroup);
+        fprintf(fd,"            p_res++;\n");
+        fprintf(fd,"            p_llrRes++;\n");
+
+         fprintf(fd,"}\n");
+        
+        }
+    }
+
+   // =====================================================================
+ 
+    
+fprintf(fd,  "// Process group with 19 CNs \n");
+
+
+
+    if (lut_numBnInBnGroups[18] > 0)
+    {
+  // If elements in group move to next address
+        idxBnGroup++;
+
+        // Number of groups of 32 BNs for parallel processing
+        M = (lut_numBnInBnGroups[18]*Z + 31)>>5;
+
+        // Set the offset to each CN within a group in terms of 16 Byte
+        cnOffsetInGroup = (lut_numBnInBnGroups[18]*NR_LDPC_ZMAX)>>5;
+
+        // Set pointers to start of group 2
+        fprintf(fd,"    p_bnProcBuf     = (__m256i*) &bnProcBuf    [%d];\n",lut_startAddrBnGroups[idxBnGroup]);
+        fprintf(fd,"   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [%d];\n",lut_startAddrBnGroups[idxBnGroup]); 
+            
+            // Loop over CNs
+        for (k=0; k<19; k++)
+        {
+        fprintf(fd,"            p_res = &p_bnProcBufRes[%d];\n", k*cnOffsetInGroup);
+        fprintf(fd,"            p_llrRes = (__m256i*) &llrRes  [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+
+          // Loop over BNs
+        fprintf(fd,"            for (int i=0;i<%d;i++) {\n",M);
+        fprintf(fd,"            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[%d + i]);\n",k*cnOffsetInGroup);
+        fprintf(fd,"            p_res++;\n");
+        fprintf(fd,"            p_llrRes++;\n");
+
+         fprintf(fd,"}\n");
+        
+        }
+    }
+
+
+   // =====================================================================
+  
+    
+fprintf(fd,  "// Process group with 20 CNs \n");
+
+
+
+    if (lut_numBnInBnGroups[19] > 0)
+    {
+  // If elements in group move to next address
+        idxBnGroup++;
+
+        // Number of groups of 32 BNs for parallel processing
+        M = (lut_numBnInBnGroups[19]*Z + 31)>>5;
+
+        // Set the offset to each CN within a group in terms of 16 Byte
+        cnOffsetInGroup = (lut_numBnInBnGroups[19]*NR_LDPC_ZMAX)>>5;
+
+        // Set pointers to start of group 2
+        fprintf(fd,"    p_bnProcBuf     = (__m256i*) &bnProcBuf    [%d];\n",lut_startAddrBnGroups[idxBnGroup]);
+        fprintf(fd,"   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [%d];\n",lut_startAddrBnGroups[idxBnGroup]); 
+            
+            // Loop over CNs
+        for (k=0; k<20; k++)
+        {
+        fprintf(fd,"            p_res = &p_bnProcBufRes[%d];\n", k*cnOffsetInGroup);
+        fprintf(fd,"            p_llrRes = (__m256i*) &llrRes  [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+
+          // Loop over BNs
+        fprintf(fd,"            for (int i=0;i<%d;i++) {\n",M);
+        fprintf(fd,"            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[%d + i]);\n",k*cnOffsetInGroup);
+        fprintf(fd,"            p_res++;\n");
+        fprintf(fd,"            p_llrRes++;\n");
+
+         fprintf(fd,"}\n");
+        
+        }
+    }
+
+
+
+
+
+    // =====================================================================
+   
+fprintf(fd,  "// Process group with 21 CNs \n");
+
+
+
+ 
+
+    if (lut_numBnInBnGroups[20] > 0)
+    {
+  // If elements in group move to next address
+        idxBnGroup++;
+
+        // Number of groups of 32 BNs for parallel processing
+        M = (lut_numBnInBnGroups[20]*Z + 31)>>5;
+
+        // Set the offset to each CN within a group in terms of 16 Byte
+        cnOffsetInGroup = (lut_numBnInBnGroups[20]*NR_LDPC_ZMAX)>>5;
+
+        // Set pointers to start of group 2
+        fprintf(fd,"    p_bnProcBuf     = (__m256i*) &bnProcBuf    [%d];\n",lut_startAddrBnGroups[idxBnGroup]);
+        fprintf(fd,"   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [%d];\n",lut_startAddrBnGroups[idxBnGroup]); 
+            
+            // Loop over CNs
+        for (k=0; k<21; k++)
+        {
+        fprintf(fd,"            p_res = &p_bnProcBufRes[%d];\n", k*cnOffsetInGroup);
+        fprintf(fd,"            p_llrRes = (__m256i*) &llrRes  [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+
+          // Loop over BNs
+        fprintf(fd,"            for (int i=0;i<%d;i++) {\n",M);
+        fprintf(fd,"            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[%d + i]);\n",k*cnOffsetInGroup);
+        fprintf(fd,"            p_res++;\n");
+        fprintf(fd,"            p_llrRes++;\n");
+
+         fprintf(fd,"}\n");
+        
+        }
+    }
+      // =====================================================================
+
+
+
+fprintf(fd,  "// Process group with 22 CNs \n");
+
+
+    if (lut_numBnInBnGroups[21] > 0)
+    {
+ // If elements in group move to next address
+        idxBnGroup++;
+
+        // Number of groups of 32 BNs for parallel processing
+        M = (lut_numBnInBnGroups[21]*Z + 31)>>5;
+
+        // Set the offset to each CN within a group in terms of 16 Byte
+        cnOffsetInGroup = (lut_numBnInBnGroups[21]*NR_LDPC_ZMAX)>>5;
+
+        // Set pointers to start of group 2
+        fprintf(fd,"    p_bnProcBuf     = (__m256i*) &bnProcBuf    [%d];\n",lut_startAddrBnGroups[idxBnGroup]);
+        fprintf(fd,"   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [%d];\n",lut_startAddrBnGroups[idxBnGroup]); 
+            
+            // Loop over CNs
+        for (k=0; k<22; k++)
+        {
+        fprintf(fd,"            p_res = &p_bnProcBufRes[%d];\n", k*cnOffsetInGroup);
+        fprintf(fd,"            p_llrRes = (__m256i*) &llrRes  [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+
+          // Loop over BNs
+        fprintf(fd,"            for (int i=0;i<%d;i++) {\n",M);
+        fprintf(fd,"            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[%d + i]);\n",k*cnOffsetInGroup);
+        fprintf(fd,"            p_res++;\n");
+        fprintf(fd,"            p_llrRes++;\n");
+
+         fprintf(fd,"}\n");
+        
+        }
+    }
+
+    // =====================================================================
+  
+
+
+fprintf(fd,  "// Process group with <23 CNs \n");
+
+
+
+    if (lut_numBnInBnGroups[22] > 0)
+    {
+  // If elements in group move to next address
+        idxBnGroup++;
+
+        // Number of groups of 32 BNs for parallel processing
+        M = (lut_numBnInBnGroups[22]*Z + 31)>>5;
+
+        // Set the offset to each CN within a group in terms of 16 Byte
+        cnOffsetInGroup = (lut_numBnInBnGroups[22]*NR_LDPC_ZMAX)>>5;
+
+        // Set pointers to start of group 2
+        fprintf(fd,"    p_bnProcBuf     = (__m256i*) &bnProcBuf    [%d];\n",lut_startAddrBnGroups[idxBnGroup]);
+        fprintf(fd,"   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [%d];\n",lut_startAddrBnGroups[idxBnGroup]); 
+            
+            // Loop over CNs
+        for (k=0; k<23; k++)
+        {
+        fprintf(fd,"            p_res = &p_bnProcBufRes[%d];\n", k*cnOffsetInGroup);
+        fprintf(fd,"            p_llrRes = (__m256i*) &llrRes  [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+
+          // Loop over BNs
+        fprintf(fd,"            for (int i=0;i<%d;i++) {\n",M);
+        fprintf(fd,"            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[%d + i]);\n",k*cnOffsetInGroup);
+        fprintf(fd,"            p_res++;\n");
+        fprintf(fd,"            p_llrRes++;\n");
+
+         fprintf(fd,"}\n");
+        
+        }
+    }
+
+
+
+    // =====================================================================
+ 
+
+fprintf(fd,  "// Process group with 24 CNs \n");
+
+ // Process group with 4 CNs
+
+    if (lut_numBnInBnGroups[23] > 0)
+    {
+ // If elements in group move to next address
+        idxBnGroup++;
+
+        // Number of groups of 32 BNs for parallel processing
+        M = (lut_numBnInBnGroups[23]*Z + 31)>>5;
+
+        // Set the offset to each CN within a group in terms of 16 Byte
+        cnOffsetInGroup = (lut_numBnInBnGroups[23]*NR_LDPC_ZMAX)>>5;
+
+        // Set pointers to start of group 2
+        fprintf(fd,"    p_bnProcBuf     = (__m256i*) &bnProcBuf    [%d];\n",lut_startAddrBnGroups[idxBnGroup]);
+        fprintf(fd,"   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [%d];\n",lut_startAddrBnGroups[idxBnGroup]); 
+            
+            // Loop over CNs
+        for (k=0; k<24; k++)
+        {
+        fprintf(fd,"            p_res = &p_bnProcBufRes[%d];\n", k*cnOffsetInGroup);
+        fprintf(fd,"            p_llrRes = (__m256i*) &llrRes  [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+
+          // Loop over BNs
+        fprintf(fd,"            for (int i=0;i<%d;i++) {\n",M);
+        fprintf(fd,"            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[%d + i]);\n",k*cnOffsetInGroup);
+        fprintf(fd,"            p_res++;\n");
+        fprintf(fd,"            p_llrRes++;\n");
+
+         fprintf(fd,"}\n");
+        
+        }
+    }
+
+
+   // =====================================================================
+  
+    
+fprintf(fd,  "// Process group with 25 CNs \n");
+
+
+
+    if (lut_numBnInBnGroups[24] > 0)
+    {
+ // If elements in group move to next address
+        idxBnGroup++;
+
+        // Number of groups of 32 BNs for parallel processing
+        M = (lut_numBnInBnGroups[24]*Z + 31)>>5;
+
+        // Set the offset to each CN within a group in terms of 16 Byte
+        cnOffsetInGroup = (lut_numBnInBnGroups[24]*NR_LDPC_ZMAX)>>5;
+
+        // Set pointers to start of group 2
+        fprintf(fd,"    p_bnProcBuf     = (__m256i*) &bnProcBuf    [%d];\n",lut_startAddrBnGroups[idxBnGroup]);
+        fprintf(fd,"   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [%d];\n",lut_startAddrBnGroups[idxBnGroup]); 
+            
+            // Loop over CNs
+        for (k=0; k<25; k++)
+        {
+        fprintf(fd,"            p_res = &p_bnProcBufRes[%d];\n", k*cnOffsetInGroup);
+        fprintf(fd,"            p_llrRes = (__m256i*) &llrRes  [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+
+          // Loop over BNs
+        fprintf(fd,"            for (int i=0;i<%d;i++) {\n",M);
+        fprintf(fd,"            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[%d + i]);\n",k*cnOffsetInGroup);
+        fprintf(fd,"            p_res++;\n");
+        fprintf(fd,"            p_llrRes++;\n");
+
+         fprintf(fd,"}\n");
+        
+        }
+    }
+
+
+
+   // =====================================================================
+   
+    
+fprintf(fd,  "// Process group with 26 CNs \n");
+
+ 
+
+    if (lut_numBnInBnGroups[25] > 0)
+    {
+ // If elements in group move to next address
+        idxBnGroup++;
+
+        // Number of groups of 32 BNs for parallel processing
+        M = (lut_numBnInBnGroups[25]*Z + 31)>>5;
+
+        // Set the offset to each CN within a group in terms of 16 Byte
+        cnOffsetInGroup = (lut_numBnInBnGroups[25]*NR_LDPC_ZMAX)>>5;
+
+        // Set pointers to start of group 2
+        fprintf(fd,"    p_bnProcBuf     = (__m256i*) &bnProcBuf    [%d];\n",lut_startAddrBnGroups[idxBnGroup]);
+        fprintf(fd,"   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [%d];\n",lut_startAddrBnGroups[idxBnGroup]); 
+            
+            // Loop over CNs
+        for (k=0; k<26; k++)
+        {
+        fprintf(fd,"            p_res = &p_bnProcBufRes[%d];\n", k*cnOffsetInGroup);
+        fprintf(fd,"            p_llrRes = (__m256i*) &llrRes  [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+
+          // Loop over BNs
+        fprintf(fd,"            for (int i=0;i<%d;i++) {\n",M);
+        fprintf(fd,"            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[%d + i]);\n",k*cnOffsetInGroup);
+        fprintf(fd,"            p_res++;\n");
+        fprintf(fd,"            p_llrRes++;\n");
+
+         fprintf(fd,"}\n");
+        
+        }
+    }
+
+
+   // =====================================================================
+
+    
+fprintf(fd,  "// Process group with 27 CNs \n");
+
+ // Process group with 17 CNs
+
+    if (lut_numBnInBnGroups[26] > 0)
+    {
+ // If elements in group move to next address
+        idxBnGroup++;
+
+        // Number of groups of 32 BNs for parallel processing
+        M = (lut_numBnInBnGroups[26]*Z + 31)>>5;
+
+        // Set the offset to each CN within a group in terms of 16 Byte
+        cnOffsetInGroup = (lut_numBnInBnGroups[26]*NR_LDPC_ZMAX)>>5;
+
+        // Set pointers to start of group 2
+        fprintf(fd,"    p_bnProcBuf     = (__m256i*) &bnProcBuf    [%d];\n",lut_startAddrBnGroups[idxBnGroup]);
+        fprintf(fd,"   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [%d];\n",lut_startAddrBnGroups[idxBnGroup]); 
+            
+            // Loop over CNs
+        for (k=0; k<27; k++)
+        {
+        fprintf(fd,"            p_res = &p_bnProcBufRes[%d];\n", k*cnOffsetInGroup);
+        fprintf(fd,"            p_llrRes = (__m256i*) &llrRes  [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+
+          // Loop over BNs
+        fprintf(fd,"            for (int i=0;i<%d;i++) {\n",M);
+        fprintf(fd,"            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[%d + i]);\n",k*cnOffsetInGroup);
+        fprintf(fd,"            p_res++;\n");
+        fprintf(fd,"            p_llrRes++;\n");
+
+         fprintf(fd,"}\n");
+        
+        }
+    }
+
+
+   // =====================================================================
+    
+    
+fprintf(fd,  "// Process group with 28 CNs \n");
+
+ // Process group with 8 CNs
+
+    if (lut_numBnInBnGroups[27] > 0)
+    {
+ // If elements in group move to next address
+        idxBnGroup++;
+
+        // Number of groups of 32 BNs for parallel processing
+        M = (lut_numBnInBnGroups[27]*Z + 31)>>5;
+
+        // Set the offset to each CN within a group in terms of 16 Byte
+        cnOffsetInGroup = (lut_numBnInBnGroups[27]*NR_LDPC_ZMAX)>>5;
+
+        // Set pointers to start of group 2
+        fprintf(fd,"    p_bnProcBuf     = (__m256i*) &bnProcBuf    [%d];\n",lut_startAddrBnGroups[idxBnGroup]);
+        fprintf(fd,"   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [%d];\n",lut_startAddrBnGroups[idxBnGroup]); 
+            
+            // Loop over CNs
+        for (k=0; k<28; k++)
+        {
+        fprintf(fd,"            p_res = &p_bnProcBufRes[%d];\n", k*cnOffsetInGroup);
+        fprintf(fd,"            p_llrRes = (__m256i*) &llrRes  [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+
+          // Loop over BNs
+        fprintf(fd,"            for (int i=0;i<%d;i++) {\n",M);
+        fprintf(fd,"            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[%d + i]);\n",k*cnOffsetInGroup);
+        fprintf(fd,"            p_res++;\n");
+        fprintf(fd,"            p_llrRes++;\n");
+
+         fprintf(fd,"}\n");
+        
+        }
+    }
+
+   // =====================================================================
+  
+fprintf(fd,  "// Process group with 29 CNs \n");
+
+ // Process group with 9 CNs
+
+    if (lut_numBnInBnGroups[28] > 0)
+    {
+ // If elements in group move to next address
+        idxBnGroup++;
+
+        // Number of groups of 32 BNs for parallel processing
+        M = (lut_numBnInBnGroups[28]*Z + 31)>>5;
+
+        // Set the offset to each CN within a group in terms of 16 Byte
+        cnOffsetInGroup = (lut_numBnInBnGroups[28]*NR_LDPC_ZMAX)>>5;
+
+        // Set pointers to start of group 2
+        fprintf(fd,"    p_bnProcBuf     = (__m256i*) &bnProcBuf    [%d];\n",lut_startAddrBnGroups[idxBnGroup]);
+        fprintf(fd,"   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [%d];\n",lut_startAddrBnGroups[idxBnGroup]); 
+            
+            // Loop over CNs
+        for (k=0; k<29; k++)
+        {
+        fprintf(fd,"            p_res = &p_bnProcBufRes[%d];\n", k*cnOffsetInGroup);
+        fprintf(fd,"            p_llrRes = (__m256i*) &llrRes  [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+
+          // Loop over BNs
+        fprintf(fd,"            for (int i=0;i<%d;i++) {\n",M);
+        fprintf(fd,"            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[%d + i]);\n",k*cnOffsetInGroup);
+        fprintf(fd,"            p_res++;\n");
+        fprintf(fd,"            p_llrRes++;\n");
+
+         fprintf(fd,"}\n");
+        
+        }
+    }
+
+
+   // =====================================================================
+
+fprintf(fd,  "// Process group with 30 CNs \n");
+
+ // Process group with 20 CNs
+
+    if (lut_numBnInBnGroups[29] > 0)
+    {
+ // If elements in group move to next address
+        idxBnGroup++;
+
+        // Number of groups of 32 BNs for parallel processing
+        M = (lut_numBnInBnGroups[29]*Z + 31)>>5;
+
+        // Set the offset to each CN within a group in terms of 16 Byte
+        cnOffsetInGroup = (lut_numBnInBnGroups[29]*NR_LDPC_ZMAX)>>5;
+
+        // Set pointers to start of group 2
+        fprintf(fd,"    p_bnProcBuf     = (__m256i*) &bnProcBuf    [%d];\n",lut_startAddrBnGroups[idxBnGroup]);
+        fprintf(fd,"   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [%d];\n",lut_startAddrBnGroups[idxBnGroup]); 
+            
+            // Loop over CNs
+        for (k=0; k<30; k++)
+        {
+        fprintf(fd,"            p_res = &p_bnProcBufRes[%d];\n", k*cnOffsetInGroup);
+        fprintf(fd,"            p_llrRes = (__m256i*) &llrRes  [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+
+          // Loop over BNs
+        fprintf(fd,"            for (int i=0;i<%d;i++) {\n",M);
+        fprintf(fd,"            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[%d + i]);\n",k*cnOffsetInGroup);
+        fprintf(fd,"            p_res++;\n");
+        fprintf(fd,"            p_llrRes++;\n");
+
+         fprintf(fd,"}\n");
+        
+        }
+    }
+
+    fprintf(fd,"}\n");
+  fclose(fd);
+}//end of the function  nrLDPC_bnProc_BG1
+
+
+
+
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_bnProc/bnProc_gen_BG2_avx2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_bnProc/bnProc_gen_BG2_avx2.c
new file mode 100644
index 0000000000..d36aa8e21b
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_bnProc/bnProc_gen_BG2_avx2.c
@@ -0,0 +1,1232 @@
+#include <stdint.h>
+#include <immintrin.h>
+#include "../../nrLDPCdecoder_defs.h"
+#include "../../nrLDPC_types.h"
+#include "../../nrLDPC_bnProc.h"
+#include "../../nrLDPC_cnProc.h"
+#include "../../nrLDPC_init.h"
+
+void nrLDPC_bnProc_BG2_generator_AVX2(uint16_t Z,int R)
+{
+  const char *ratestr[3]={"15","13","23"};
+
+  if (R<0 || R>2) {printf("Illegal R %d\n",R); abort();}
+
+
+ // system("mkdir -p ../ldpc_gen_files");
+
+  char fname[50];
+  sprintf(fname,"../ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z%d_R%s_AVX2.c",Z,ratestr[R]);
+  FILE *fd=fopen(fname,"w");
+  if (fd == NULL) {printf("Cannot create \n");abort();}
+
+  fprintf(fd,"#include <stdint.h>\n");
+  fprintf(fd,"#include <immintrin.h>\n");
+    
+    fprintf(fd,"void nrLDPC_bnProc_BG2_Z%d_R%s_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes,  int8_t* llrRes  ) {\n",Z, ratestr[R]);
+    const uint8_t*  lut_numBnInBnGroups;
+    const uint32_t* lut_startAddrBnGroups;
+    const uint16_t* lut_startAddrBnGroupsLlr;
+    if (R==0) {
+
+
+      lut_numBnInBnGroups =  lut_numBnInBnGroups_BG2_R15;
+      lut_startAddrBnGroups = lut_startAddrBnGroups_BG2_R15;
+      lut_startAddrBnGroupsLlr = lut_startAddrBnGroupsLlr_BG2_R15;
+
+    }
+    else if (R==1){
+
+      lut_numBnInBnGroups =  lut_numBnInBnGroups_BG2_R13;
+      lut_startAddrBnGroups = lut_startAddrBnGroups_BG2_R13;
+      lut_startAddrBnGroupsLlr = lut_startAddrBnGroupsLlr_BG2_R13;
+    }
+    else if (R==2) {
+
+      lut_numBnInBnGroups = lut_numBnInBnGroups_BG2_R23;
+      lut_startAddrBnGroups = lut_startAddrBnGroups_BG2_R23;
+      lut_startAddrBnGroupsLlr = lut_startAddrBnGroupsLlr_BG2_R23;
+    }
+  else { printf("aborting, illegal R %d\n",R); fclose(fd);abort();}
+
+
+    uint32_t M;
+    //uint32_t M32rem;
+   // uint32_t i;
+    uint32_t k;
+    // Offset to each bit within a group in terms of 32 Byte
+    uint32_t cnOffsetInGroup;
+    uint8_t idxBnGroup = 0;
+
+
+    
+    fprintf(fd,"        __m256i* p_bnProcBuf; \n");
+    fprintf(fd,"        __m256i* p_bnProcBufRes; \n");
+    fprintf(fd,"        __m256i* p_llrRes; \n");
+    fprintf(fd,"        __m256i* p_res; \n");
+
+
+
+// =====================================================================
+    // Process group with 1 CN
+    // Already done in bnProcBufPc
+
+    // =====================================================================
+
+fprintf(fd,  "// Process group with 2 CNs \n");
+
+    if (lut_numBnInBnGroups[1] > 0)
+    {
+ // If elements in group move to next address
+        idxBnGroup++;
+
+        // Number of groups of 32 BNs for parallel processing
+        M = (lut_numBnInBnGroups[1]*Z + 31)>>5;
+
+        // Set the offset to each CN within a group in terms of 16 Byte
+        cnOffsetInGroup = (lut_numBnInBnGroups[1]*NR_LDPC_ZMAX)>>5;
+
+        // Set pointers to start of group 2
+        fprintf(fd,"    p_bnProcBuf     = (__m256i*) &bnProcBuf    [%d];\n",lut_startAddrBnGroups[idxBnGroup]);
+        fprintf(fd,"   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [%d];\n",lut_startAddrBnGroups[idxBnGroup]); 
+            
+            // Loop over CNs
+        for (k=0; k<2; k++)
+        {
+        fprintf(fd,"            p_res = &p_bnProcBufRes[%d];\n", k*cnOffsetInGroup);
+        fprintf(fd,"            p_llrRes = (__m256i*) &llrRes  [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+
+          // Loop over BNs
+        fprintf(fd,"            for (int i=0;i<%d;i++) {\n",M);
+        fprintf(fd,"            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[%d + i]);\n",k*cnOffsetInGroup);
+        fprintf(fd,"             p_res++;\n");
+        fprintf(fd,"             p_llrRes++;\n");
+
+         fprintf(fd,"}\n");
+        
+        }
+
+        
+       
+    }
+
+    // =====================================================================
+
+
+fprintf(fd,  "// Process group with 3 CNs \n");
+
+
+
+    if (lut_numBnInBnGroups[2] > 0)
+    {
+ // If elements in group move to next address
+        idxBnGroup++;
+
+        // Number of groups of 32 BNs for parallel processing
+        M = (lut_numBnInBnGroups[2]*Z + 31)>>5;
+
+        // Set the offset to each CN within a group in terms of 16 Byte
+        cnOffsetInGroup = (lut_numBnInBnGroups[2]*NR_LDPC_ZMAX)>>5;
+
+        // Set pointers to start of group 2
+        fprintf(fd,"    p_bnProcBuf     = (__m256i*) &bnProcBuf    [%d];\n",lut_startAddrBnGroups[idxBnGroup]);
+        fprintf(fd,"   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [%d];\n",lut_startAddrBnGroups[idxBnGroup]); 
+            
+        for (k=0; k<3; k++)
+        {
+        fprintf(fd,"            p_res = &p_bnProcBufRes[%d];\n", k*cnOffsetInGroup);
+        fprintf(fd,"            p_llrRes = (__m256i*) &llrRes  [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+
+          // Loop over BNs
+        fprintf(fd,"            for (int i=0;i<%d;i++) {\n",M);
+        fprintf(fd,"            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[%d + i]);\n",k*cnOffsetInGroup);
+        fprintf(fd,"            p_res++;\n");
+        fprintf(fd,"            p_llrRes++;\n");
+
+         fprintf(fd,"}\n");
+        }
+    }
+
+
+
+    // =====================================================================
+   
+
+fprintf(fd,  "// Process group with 4 CNs \n");
+
+ 
+
+    if (lut_numBnInBnGroups[3] > 0)
+    {
+        // If elements in group move to next address
+        idxBnGroup++;
+
+        // Number of groups of 32 BNs for parallel processing
+        M = (lut_numBnInBnGroups[3]*Z + 31)>>5;
+
+        // Set the offset to each CN within a group in terms of 16 Byte
+        cnOffsetInGroup = (lut_numBnInBnGroups[3]*NR_LDPC_ZMAX)>>5;
+
+        // Set pointers to start of group 2
+        fprintf(fd,"    p_bnProcBuf     = (__m256i*) &bnProcBuf    [%d];\n",lut_startAddrBnGroups[idxBnGroup]);
+        fprintf(fd,"   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [%d];\n",lut_startAddrBnGroups[idxBnGroup]); 
+            
+        for (k=0; k<4; k++)
+        {
+        fprintf(fd,"            p_res = &p_bnProcBufRes[%d];\n", k*cnOffsetInGroup);
+        fprintf(fd,"            p_llrRes = (__m256i*) &llrRes  [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+
+          // Loop over BNs
+        fprintf(fd,"            for (int i=0;i<%d;i++) {\n",M);
+        fprintf(fd,"            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[%d + i]);\n",k*cnOffsetInGroup);
+        fprintf(fd,"            p_res++;\n");
+        fprintf(fd,"            p_llrRes++;\n");
+
+         fprintf(fd,"}\n");
+        }
+    }
+
+
+   // =====================================================================
+
+    
+    fprintf(fd,  "// Process group with 5 CNs \n");
+
+
+
+    if (lut_numBnInBnGroups[4] > 0)
+    {
+    // If elements in group move to next address
+        idxBnGroup++;
+
+        // Number of groups of 32 BNs for parallel processing
+        M = (lut_numBnInBnGroups[4]*Z + 31)>>5;
+
+        // Set the offset to each CN within a group in terms of 16 Byte
+        cnOffsetInGroup = (lut_numBnInBnGroups[4]*NR_LDPC_ZMAX)>>5;
+
+        // Set pointers to start of group 2
+        fprintf(fd,"    p_bnProcBuf     = (__m256i*) &bnProcBuf    [%d];\n",lut_startAddrBnGroups[idxBnGroup]);
+        fprintf(fd,"   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [%d];\n",lut_startAddrBnGroups[idxBnGroup]); 
+            
+            // Loop over CNs
+        for (k=0; k<5; k++)
+        {
+        fprintf(fd,"            p_res = &p_bnProcBufRes[%d];\n", k*cnOffsetInGroup);
+        fprintf(fd,"            p_llrRes = (__m256i*) &llrRes  [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+
+          // Loop over BNs
+        fprintf(fd,"            for (int i=0;i<%d;i++) {\n",M);
+        fprintf(fd,"            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[%d + i]);\n",k*cnOffsetInGroup);
+        fprintf(fd,"            p_res++;\n");
+        fprintf(fd,"            p_llrRes++;\n");
+
+         fprintf(fd,"}\n");
+        
+        }
+    }
+
+
+
+   // =====================================================================
+ 
+    
+fprintf(fd,  "// Process group with 6 CNs \n");
+
+ // Process group with 6 CNs
+
+    if (lut_numBnInBnGroups[5] > 0)
+    {
+  // If elements in group move to next address
+        idxBnGroup++;
+
+        // Number of groups of 32 BNs for parallel processing
+        M = (lut_numBnInBnGroups[5]*Z + 31)>>5;
+
+        // Set the offset to each CN within a group in terms of 16 Byte
+        cnOffsetInGroup = (lut_numBnInBnGroups[5]*NR_LDPC_ZMAX)>>5;
+
+        // Set pointers to start of group 2
+        fprintf(fd,"    p_bnProcBuf     = (__m256i*) &bnProcBuf    [%d];\n",lut_startAddrBnGroups[idxBnGroup]);
+        fprintf(fd,"   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [%d];\n",lut_startAddrBnGroups[idxBnGroup]); 
+            
+            // Loop over CNs
+        for (k=0; k<6; k++)
+        {
+        fprintf(fd,"            p_res = &p_bnProcBufRes[%d];\n", k*cnOffsetInGroup);
+        fprintf(fd,"            p_llrRes = (__m256i*) &llrRes  [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+
+          // Loop over BNs
+        fprintf(fd,"            for (int i=0;i<%d;i++) {\n",M);
+        fprintf(fd,"            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[%d + i]);\n",k*cnOffsetInGroup);
+        fprintf(fd,"            p_res++;\n");
+        fprintf(fd,"            p_llrRes++;\n");
+
+         fprintf(fd,"}\n");
+        
+        }
+    }
+
+
+   // =====================================================================
+
+    
+fprintf(fd,  "// Process group with 7 CNs \n");
+
+ // Process group with 7 CNs
+
+    if (lut_numBnInBnGroups[6] > 0)
+    {
+  // If elements in group move to next address
+        idxBnGroup++;
+
+        // Number of groups of 32 BNs for parallel processing
+        M = (lut_numBnInBnGroups[6]*Z + 31)>>5;
+
+        // Set the offset to each CN within a group in terms of 16 Byte
+        cnOffsetInGroup = (lut_numBnInBnGroups[6]*NR_LDPC_ZMAX)>>5;
+
+        // Set pointers to start of group 2
+        fprintf(fd,"    p_bnProcBuf     = (__m256i*) &bnProcBuf    [%d];\n",lut_startAddrBnGroups[idxBnGroup]);
+        fprintf(fd,"   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [%d];\n",lut_startAddrBnGroups[idxBnGroup]); 
+            
+            // Loop over CNs
+        for (k=0; k<7; k++)
+        {
+        fprintf(fd,"            p_res = &p_bnProcBufRes[%d];\n", k*cnOffsetInGroup);
+        fprintf(fd,"            p_llrRes = (__m256i*) &llrRes  [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+
+          // Loop over BNs
+        fprintf(fd,"            for (int i=0;i<%d;i++) {\n",M);
+        fprintf(fd,"            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[%d + i]);\n",k*cnOffsetInGroup);
+        fprintf(fd,"            p_res++;\n");
+        fprintf(fd,"            p_llrRes++;\n");
+
+         fprintf(fd,"}\n");
+        
+        }
+    }
+
+
+   // =====================================================================
+ 
+    
+fprintf(fd,  "// Process group with 8 CNs \n");
+
+ // Process group with 8 CNs
+
+    if (lut_numBnInBnGroups[7] > 0)
+    {
+ // If elements in group move to next address
+        idxBnGroup++;
+
+        // Number of groups of 32 BNs for parallel processing
+        M = (lut_numBnInBnGroups[7]*Z + 31)>>5;
+
+        // Set the offset to each CN within a group in terms of 16 Byte
+        cnOffsetInGroup = (lut_numBnInBnGroups[7]*NR_LDPC_ZMAX)>>5;
+
+        // Set pointers to start of group 2
+        fprintf(fd,"    p_bnProcBuf     = (__m256i*) &bnProcBuf    [%d];\n",lut_startAddrBnGroups[idxBnGroup]);
+        fprintf(fd,"   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [%d];\n",lut_startAddrBnGroups[idxBnGroup]); 
+            
+            // Loop over CNs
+        for (k=0; k<8; k++)
+        {
+        fprintf(fd,"            p_res = &p_bnProcBufRes[%d];\n", k*cnOffsetInGroup);
+        fprintf(fd,"            p_llrRes = (__m256i*) &llrRes  [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+
+          // Loop over BNs
+        fprintf(fd,"            for (int i=0;i<%d;i++) {\n",M);
+        fprintf(fd,"            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[%d + i]);\n",k*cnOffsetInGroup);
+        fprintf(fd,"            p_res++;\n");
+        fprintf(fd,"            p_llrRes++;\n");
+
+         fprintf(fd,"}\n");
+        
+        }
+    }
+
+   // =====================================================================
+
+    
+fprintf(fd,  "// Process group with 9 CNs \n");
+
+ // Process group with 9 CNs
+
+    if (lut_numBnInBnGroups[8] > 0)
+    {
+  // If elements in group move to next address
+        idxBnGroup++;
+
+        // Number of groups of 32 BNs for parallel processing
+        M = (lut_numBnInBnGroups[8]*Z + 31)>>5;
+
+        // Set the offset to each CN within a group in terms of 16 Byte
+        cnOffsetInGroup = (lut_numBnInBnGroups[8]*NR_LDPC_ZMAX)>>5;
+
+        // Set pointers to start of group 2
+        fprintf(fd,"    p_bnProcBuf     = (__m256i*) &bnProcBuf    [%d];\n",lut_startAddrBnGroups[idxBnGroup]);
+        fprintf(fd,"   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [%d];\n",lut_startAddrBnGroups[idxBnGroup]); 
+            
+            // Loop over CNs
+        for (k=0; k<9; k++)
+        {
+        fprintf(fd,"            p_res = &p_bnProcBufRes[%d];\n", k*cnOffsetInGroup);
+        fprintf(fd,"            p_llrRes = (__m256i*) &llrRes  [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+
+          // Loop over BNs
+        fprintf(fd,"            for (int i=0;i<%d;i++) {\n",M);
+        fprintf(fd,"            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[%d + i]);\n",k*cnOffsetInGroup);
+        fprintf(fd,"            p_res++;\n");
+        fprintf(fd,"            p_llrRes++;\n");
+
+         fprintf(fd,"}\n");
+        
+        }
+    }
+
+
+   // =====================================================================
+
+fprintf(fd,  "// Process group with 10 CNs \n");
+
+ // Process group with 10 CNs
+
+    if (lut_numBnInBnGroups[9] > 0)
+    {
+ // If elements in group move to next address
+        idxBnGroup++;
+
+        // Number of groups of 32 BNs for parallel processing
+        M = (lut_numBnInBnGroups[9]*Z + 31)>>5;
+
+        // Set the offset to each CN within a group in terms of 16 Byte
+        cnOffsetInGroup = (lut_numBnInBnGroups[9]*NR_LDPC_ZMAX)>>5;
+
+        // Set pointers to start of group 2
+        fprintf(fd,"    p_bnProcBuf     = (__m256i*) &bnProcBuf    [%d];\n",lut_startAddrBnGroups[idxBnGroup]);
+        fprintf(fd,"   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [%d];\n",lut_startAddrBnGroups[idxBnGroup]); 
+            
+            // Loop over CNs
+        for (k=0; k<10; k++)
+        {
+        fprintf(fd,"            p_res = &p_bnProcBufRes[%d];\n", k*cnOffsetInGroup);
+        fprintf(fd,"            p_llrRes = (__m256i*) &llrRes  [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+
+          // Loop over BNs
+        fprintf(fd,"            for (int i=0;i<%d;i++) {\n",M);
+        fprintf(fd,"            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[%d + i]);\n",k*cnOffsetInGroup);
+        fprintf(fd,"            p_res++;\n");
+        fprintf(fd,"            p_llrRes++;\n");
+
+         fprintf(fd,"}\n");
+        
+        }
+    }
+
+
+
+    // =====================================================================
+   
+fprintf(fd,  "// Process group with 11 CNs \n");
+
+    if (lut_numBnInBnGroups[10] > 0)
+    {
+  // If elements in group move to next address
+        idxBnGroup++;
+
+        // Number of groups of 32 BNs for parallel processing
+        M = (lut_numBnInBnGroups[10]*Z + 31)>>5;
+
+        // Set the offset to each CN within a group in terms of 16 Byte
+        cnOffsetInGroup = (lut_numBnInBnGroups[10]*NR_LDPC_ZMAX)>>5;
+
+        // Set pointers to start of group 2
+        fprintf(fd,"    p_bnProcBuf     = (__m256i*) &bnProcBuf    [%d];\n",lut_startAddrBnGroups[idxBnGroup]);
+        fprintf(fd,"   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [%d];\n",lut_startAddrBnGroups[idxBnGroup]); 
+            
+            // Loop over CNs
+        for (k=0; k<11; k++)
+        {
+        fprintf(fd,"            p_res = &p_bnProcBufRes[%d];\n", k*cnOffsetInGroup);
+        fprintf(fd,"            p_llrRes = (__m256i*) &llrRes  [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+
+          // Loop over BNs
+        fprintf(fd,"            for (int i=0;i<%d;i++) {\n",M);
+        fprintf(fd,"            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[%d + i]);\n",k*cnOffsetInGroup);
+        fprintf(fd,"            p_res++;\n");
+        fprintf(fd,"            p_llrRes++;\n");
+
+         fprintf(fd,"}\n");
+        
+        }
+    }
+      // =====================================================================
+
+
+
+fprintf(fd,  "// Process group with 12 CNs \n");
+
+
+    if (lut_numBnInBnGroups[11] > 0)
+    {
+  // If elements in group move to next address
+        idxBnGroup++;
+
+        // Number of groups of 32 BNs for parallel processing
+        M = (lut_numBnInBnGroups[11]*Z + 31)>>5;
+
+        // Set the offset to each CN within a group in terms of 16 Byte
+        cnOffsetInGroup = (lut_numBnInBnGroups[11]*NR_LDPC_ZMAX)>>5;
+
+        // Set pointers to start of group 2
+        fprintf(fd,"    p_bnProcBuf     = (__m256i*) &bnProcBuf    [%d];\n",lut_startAddrBnGroups[idxBnGroup]);
+        fprintf(fd,"   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [%d];\n",lut_startAddrBnGroups[idxBnGroup]); 
+            
+            // Loop over CNs
+        for (k=0; k<12; k++)
+        {
+        fprintf(fd,"            p_res = &p_bnProcBufRes[%d];\n", k*cnOffsetInGroup);
+        fprintf(fd,"            p_llrRes = (__m256i*) &llrRes  [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+
+          // Loop over BNs
+        fprintf(fd,"            for (int i=0;i<%d;i++) {\n",M);
+        fprintf(fd,"            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[%d + i]);\n",k*cnOffsetInGroup);
+        fprintf(fd,"            p_res++;\n");
+        fprintf(fd,"            p_llrRes++;\n");
+
+         fprintf(fd,"}\n");
+        
+        }
+    }
+
+    // =====================================================================
+
+
+
+fprintf(fd,  "// Process group with 13 CNs \n");
+
+
+
+    if (lut_numBnInBnGroups[12] > 0)
+    {
+  // If elements in group move to next address
+        idxBnGroup++;
+
+        // Number of groups of 32 BNs for parallel processing
+        M = (lut_numBnInBnGroups[12]*Z + 31)>>5;
+
+        // Set the offset to each CN within a group in terms of 16 Byte
+        cnOffsetInGroup = (lut_numBnInBnGroups[12]*NR_LDPC_ZMAX)>>5;
+
+        // Set pointers to start of group 2
+        fprintf(fd,"    p_bnProcBuf     = (__m256i*) &bnProcBuf    [%d];\n",lut_startAddrBnGroups[idxBnGroup]);
+        fprintf(fd,"   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [%d];\n",lut_startAddrBnGroups[idxBnGroup]); 
+            
+            // Loop over CNs
+        for (k=0; k<1; k++)
+        {
+        fprintf(fd,"            p_res = &p_bnProcBufRes[%d];\n", k*cnOffsetInGroup);
+        fprintf(fd,"            p_llrRes = (__m256i*) &llrRes  [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+
+          // Loop over BNs
+        fprintf(fd,"            for (int i=0;i<%d;i++) {\n",M);
+        fprintf(fd,"            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[%d + i]);\n",k*cnOffsetInGroup);
+        fprintf(fd,"            p_res++;\n");
+        fprintf(fd,"            p_llrRes++;\n");
+
+         fprintf(fd,"}\n");
+        
+        }
+    }
+
+
+
+    // =====================================================================
+   
+
+fprintf(fd,  "// Process group with 14 CNs \n");
+
+
+
+    if (lut_numBnInBnGroups[13] > 0)
+    {
+  // If elements in group move to next address
+        idxBnGroup++;
+
+        // Number of groups of 32 BNs for parallel processing
+        M = (lut_numBnInBnGroups[13]*Z + 31)>>5;
+
+        // Set the offset to each CN within a group in terms of 16 Byte
+        cnOffsetInGroup = (lut_numBnInBnGroups[13]*NR_LDPC_ZMAX)>>5;
+
+        // Set pointers to start of group 2
+        fprintf(fd,"    p_bnProcBuf     = (__m256i*) &bnProcBuf    [%d];\n",lut_startAddrBnGroups[idxBnGroup]);
+        fprintf(fd,"   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [%d];\n",lut_startAddrBnGroups[idxBnGroup]); 
+            
+            // Loop over CNs
+        for (k=0; k<14; k++)
+        {
+        fprintf(fd,"            p_res = &p_bnProcBufRes[%d];\n", k*cnOffsetInGroup);
+        fprintf(fd,"            p_llrRes = (__m256i*) &llrRes  [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+
+          // Loop over BNs
+        fprintf(fd,"            for (int i=0;i<%d;i++) {\n",M);
+        fprintf(fd,"            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[%d + i]);\n",k*cnOffsetInGroup);
+        fprintf(fd,"            p_res++;\n");
+        fprintf(fd,"            p_llrRes++;\n");
+
+         fprintf(fd,"}\n");
+        
+        }
+    }
+
+
+   // =====================================================================
+
+    
+fprintf(fd,  "// Process group with 15 CNs \n");
+
+
+
+    if (lut_numBnInBnGroups[14] > 0)
+    {
+ // If elements in group move to next address
+        idxBnGroup++;
+
+        // Number of groups of 32 BNs for parallel processing
+        M = (lut_numBnInBnGroups[14]*Z + 31)>>5;
+
+        // Set the offset to each CN within a group in terms of 16 Byte
+        cnOffsetInGroup = (lut_numBnInBnGroups[14]*NR_LDPC_ZMAX)>>5;
+
+        // Set pointers to start of group 2
+        fprintf(fd,"    p_bnProcBuf     = (__m256i*) &bnProcBuf    [%d];\n",lut_startAddrBnGroups[idxBnGroup]);
+        fprintf(fd,"   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [%d];\n",lut_startAddrBnGroups[idxBnGroup]); 
+            
+            // Loop over CNs
+        for (k=0; k<15; k++)
+        {
+        fprintf(fd,"            p_res = &p_bnProcBufRes[%d];\n", k*cnOffsetInGroup);
+        fprintf(fd,"            p_llrRes = (__m256i*) &llrRes  [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+
+          // Loop over BNs
+        fprintf(fd,"            for (int i=0;i<%d;i++) {\n",M);
+        fprintf(fd,"            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[%d + i]);\n",k*cnOffsetInGroup);
+        fprintf(fd,"            p_res++;\n");
+        fprintf(fd,"            p_llrRes++;\n");
+
+         fprintf(fd,"}\n");
+        
+        }
+    }
+
+
+
+   // =====================================================================
+
+    
+fprintf(fd,  "// Process group with 16 CNs \n");
+
+ 
+
+    if (lut_numBnInBnGroups[15] > 0)
+    {
+ // If elements in group move to next address
+        idxBnGroup++;
+
+        // Number of groups of 32 BNs for parallel processing
+        M = (lut_numBnInBnGroups[15]*Z + 31)>>5;
+
+        // Set the offset to each CN within a group in terms of 16 Byte
+        cnOffsetInGroup = (lut_numBnInBnGroups[15]*NR_LDPC_ZMAX)>>5;
+
+        // Set pointers to start of group 2
+        fprintf(fd,"    p_bnProcBuf     = (__m256i*) &bnProcBuf    [%d];\n",lut_startAddrBnGroups[idxBnGroup]);
+        fprintf(fd,"   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [%d];\n",lut_startAddrBnGroups[idxBnGroup]); 
+            
+            // Loop over CNs
+        for (k=0; k<16; k++)
+        {
+        fprintf(fd,"            p_res = &p_bnProcBufRes[%d];\n", k*cnOffsetInGroup);
+        fprintf(fd,"            p_llrRes = (__m256i*) &llrRes  [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+
+          // Loop over BNs
+        fprintf(fd,"            for (int i=0;i<%d;i++) {\n",M);
+        fprintf(fd,"            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[%d + i]);\n",k*cnOffsetInGroup);
+        fprintf(fd,"            p_res++;\n");
+        fprintf(fd,"            p_llrRes++;\n");
+
+         fprintf(fd,"}\n");
+        
+        }
+    }
+
+
+   // =====================================================================
+    // Process group with 17 CNs
+    
+fprintf(fd,  "// Process group with 17 CNs \n");
+
+ // Process group with 17 CNs
+
+    if (lut_numBnInBnGroups[16] > 0)
+    {
+ // If elements in group move to next address
+        idxBnGroup++;
+
+        // Number of groups of 32 BNs for parallel processing
+        M = (lut_numBnInBnGroups[16]*Z + 31)>>5;
+
+        // Set the offset to each CN within a group in terms of 16 Byte
+        cnOffsetInGroup = (lut_numBnInBnGroups[16]*NR_LDPC_ZMAX)>>5;
+
+        // Set pointers to start of group 2
+        fprintf(fd,"    p_bnProcBuf     = (__m256i*) &bnProcBuf    [%d];\n",lut_startAddrBnGroups[idxBnGroup]);
+        fprintf(fd,"   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [%d];\n",lut_startAddrBnGroups[idxBnGroup]); 
+            
+            // Loop over CNs
+        for (k=0; k<17; k++)
+        {
+        fprintf(fd,"            p_res = &p_bnProcBufRes[%d];\n", k*cnOffsetInGroup);
+        fprintf(fd,"            p_llrRes = (__m256i*) &llrRes  [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+
+          // Loop over BNs
+        fprintf(fd,"            for (int i=0;i<%d;i++) {\n",M);
+        fprintf(fd,"            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[%d + i]);\n",k*cnOffsetInGroup);
+        fprintf(fd,"            p_res++;\n");
+        fprintf(fd,"            p_llrRes++;\n");
+
+         fprintf(fd,"}\n");
+        
+        }
+    }
+
+
+   // =====================================================================
+ 
+    
+fprintf(fd,  "// Process group with 18 CNs \n");
+
+ // Process group with 8 CNs
+
+    if (lut_numBnInBnGroups[17] > 0)
+    {
+  // If elements in group move to next address
+        idxBnGroup++;
+
+        // Number of groups of 32 BNs for parallel processing
+        M = (lut_numBnInBnGroups[17]*Z + 31)>>5;
+
+        // Set the offset to each CN within a group in terms of 16 Byte
+        cnOffsetInGroup = (lut_numBnInBnGroups[17]*NR_LDPC_ZMAX)>>5;
+
+        // Set pointers to start of group 2
+        fprintf(fd,"    p_bnProcBuf     = (__m256i*) &bnProcBuf    [%d];\n",lut_startAddrBnGroups[idxBnGroup]);
+        fprintf(fd,"   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [%d];\n",lut_startAddrBnGroups[idxBnGroup]); 
+            
+            // Loop over CNs
+        for (k=0; k<18; k++)
+        {
+        fprintf(fd,"            p_res = &p_bnProcBufRes[%d];\n", k*cnOffsetInGroup);
+        fprintf(fd,"            p_llrRes = (__m256i*) &llrRes  [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+
+          // Loop over BNs
+        fprintf(fd,"            for (int i=0;i<%d;i++) {\n",M);
+        fprintf(fd,"            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[%d + i]);\n",k*cnOffsetInGroup);
+        fprintf(fd,"            p_res++;\n");
+        fprintf(fd,"            p_llrRes++;\n");
+
+         fprintf(fd,"}\n");
+        
+        }
+    }
+
+   // =====================================================================
+ 
+    
+fprintf(fd,  "// Process group with 19 CNs \n");
+
+
+
+    if (lut_numBnInBnGroups[18] > 0)
+    {
+  // If elements in group move to next address
+        idxBnGroup++;
+
+        // Number of groups of 32 BNs for parallel processing
+        M = (lut_numBnInBnGroups[18]*Z + 31)>>5;
+
+        // Set the offset to each CN within a group in terms of 16 Byte
+        cnOffsetInGroup = (lut_numBnInBnGroups[18]*NR_LDPC_ZMAX)>>5;
+
+        // Set pointers to start of group 2
+        fprintf(fd,"    p_bnProcBuf     = (__m256i*) &bnProcBuf    [%d];\n",lut_startAddrBnGroups[idxBnGroup]);
+        fprintf(fd,"   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [%d];\n",lut_startAddrBnGroups[idxBnGroup]); 
+            
+            // Loop over CNs
+        for (k=0; k<19; k++)
+        {
+        fprintf(fd,"            p_res = &p_bnProcBufRes[%d];\n", k*cnOffsetInGroup);
+        fprintf(fd,"            p_llrRes = (__m256i*) &llrRes  [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+
+          // Loop over BNs
+        fprintf(fd,"            for (int i=0;i<%d;i++) {\n",M);
+        fprintf(fd,"            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[%d + i]);\n",k*cnOffsetInGroup);
+        fprintf(fd,"            p_res++;\n");
+        fprintf(fd,"            p_llrRes++;\n");
+
+         fprintf(fd,"}\n");
+        
+        }
+    }
+
+
+   // =====================================================================
+  
+    
+fprintf(fd,  "// Process group with 20 CNs \n");
+
+
+
+    if (lut_numBnInBnGroups[19] > 0)
+    {
+  // If elements in group move to next address
+        idxBnGroup++;
+
+        // Number of groups of 32 BNs for parallel processing
+        M = (lut_numBnInBnGroups[19]*Z + 31)>>5;
+
+        // Set the offset to each CN within a group in terms of 16 Byte
+        cnOffsetInGroup = (lut_numBnInBnGroups[19]*NR_LDPC_ZMAX)>>5;
+
+        // Set pointers to start of group 2
+        fprintf(fd,"    p_bnProcBuf     = (__m256i*) &bnProcBuf    [%d];\n",lut_startAddrBnGroups[idxBnGroup]);
+        fprintf(fd,"   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [%d];\n",lut_startAddrBnGroups[idxBnGroup]); 
+            
+            // Loop over CNs
+        for (k=0; k<20; k++)
+        {
+        fprintf(fd,"            p_res = &p_bnProcBufRes[%d];\n", k*cnOffsetInGroup);
+        fprintf(fd,"            p_llrRes = (__m256i*) &llrRes  [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+
+          // Loop over BNs
+        fprintf(fd,"            for (int i=0;i<%d;i++) {\n",M);
+        fprintf(fd,"            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[%d + i]);\n",k*cnOffsetInGroup);
+        fprintf(fd,"            p_res++;\n");
+        fprintf(fd,"            p_llrRes++;\n");
+
+         fprintf(fd,"}\n");
+        
+        }
+    }
+
+
+
+
+
+    // =====================================================================
+   
+fprintf(fd,  "// Process group with 21 CNs \n");
+
+
+
+ 
+
+    if (lut_numBnInBnGroups[20] > 0)
+    {
+  // If elements in group move to next address
+        idxBnGroup++;
+
+        // Number of groups of 32 BNs for parallel processing
+        M = (lut_numBnInBnGroups[20]*Z + 31)>>5;
+
+        // Set the offset to each CN within a group in terms of 16 Byte
+        cnOffsetInGroup = (lut_numBnInBnGroups[20]*NR_LDPC_ZMAX)>>5;
+
+        // Set pointers to start of group 2
+        fprintf(fd,"    p_bnProcBuf     = (__m256i*) &bnProcBuf    [%d];\n",lut_startAddrBnGroups[idxBnGroup]);
+        fprintf(fd,"   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [%d];\n",lut_startAddrBnGroups[idxBnGroup]); 
+            
+            // Loop over CNs
+        for (k=0; k<21; k++)
+        {
+        fprintf(fd,"            p_res = &p_bnProcBufRes[%d];\n", k*cnOffsetInGroup);
+        fprintf(fd,"            p_llrRes = (__m256i*) &llrRes  [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+
+          // Loop over BNs
+        fprintf(fd,"            for (int i=0;i<%d;i++) {\n",M);
+        fprintf(fd,"            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[%d + i]);\n",k*cnOffsetInGroup);
+        fprintf(fd,"            p_res++;\n");
+        fprintf(fd,"            p_llrRes++;\n");
+
+         fprintf(fd,"}\n");
+        
+        }
+    }
+      // =====================================================================
+
+
+
+fprintf(fd,  "// Process group with 22 CNs \n");
+
+
+    if (lut_numBnInBnGroups[21] > 0)
+    {
+ // If elements in group move to next address
+        idxBnGroup++;
+
+        // Number of groups of 32 BNs for parallel processing
+        M = (lut_numBnInBnGroups[21]*Z + 31)>>5;
+
+        // Set the offset to each CN within a group in terms of 16 Byte
+        cnOffsetInGroup = (lut_numBnInBnGroups[21]*NR_LDPC_ZMAX)>>5;
+
+        // Set pointers to start of group 2
+        fprintf(fd,"    p_bnProcBuf     = (__m256i*) &bnProcBuf    [%d];\n",lut_startAddrBnGroups[idxBnGroup]);
+        fprintf(fd,"   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [%d];\n",lut_startAddrBnGroups[idxBnGroup]); 
+            
+            // Loop over CNs
+        for (k=0; k<22; k++)
+        {
+        fprintf(fd,"            p_res = &p_bnProcBufRes[%d];\n", k*cnOffsetInGroup);
+        fprintf(fd,"            p_llrRes = (__m256i*) &llrRes  [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+
+          // Loop over BNs
+        fprintf(fd,"            for (int i=0;i<%d;i++) {\n",M);
+        fprintf(fd,"            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[%d + i]);\n",k*cnOffsetInGroup);
+        fprintf(fd,"            p_res++;\n");
+        fprintf(fd,"            p_llrRes++;\n");
+
+         fprintf(fd,"}\n");
+        
+        }
+    }
+
+    // =====================================================================
+  
+
+
+fprintf(fd,  "// Process group with 23 CNs \n");
+
+
+
+    if (lut_numBnInBnGroups[22] > 0)
+    {
+  // If elements in group move to next address
+        idxBnGroup++;
+
+        // Number of groups of 32 BNs for parallel processing
+        M = (lut_numBnInBnGroups[22]*Z + 31)>>5;
+
+        // Set the offset to each CN within a group in terms of 16 Byte
+        cnOffsetInGroup = (lut_numBnInBnGroups[22]*NR_LDPC_ZMAX)>>5;
+
+        // Set pointers to start of group 2
+        fprintf(fd,"    p_bnProcBuf     = (__m256i*) &bnProcBuf    [%d];\n",lut_startAddrBnGroups[idxBnGroup]);
+        fprintf(fd,"   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [%d];\n",lut_startAddrBnGroups[idxBnGroup]); 
+            
+            // Loop over CNs
+        for (k=0; k<23; k++)
+        {
+        fprintf(fd,"            p_res = &p_bnProcBufRes[%d];\n", k*cnOffsetInGroup);
+        fprintf(fd,"            p_llrRes = (__m256i*) &llrRes  [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+
+          // Loop over BNs
+        fprintf(fd,"            for (int i=0;i<%d;i++) {\n",M);
+        fprintf(fd,"            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[%d + i]);\n",k*cnOffsetInGroup);
+        fprintf(fd,"            p_res++;\n");
+        fprintf(fd,"            p_llrRes++;\n");
+
+         fprintf(fd,"}\n");
+        
+        }
+    }
+
+
+
+    // =====================================================================
+ 
+
+fprintf(fd,  "// Process group with 24 CNs \n");
+
+ // Process group with 4 CNs
+
+    if (lut_numBnInBnGroups[23] > 0)
+    {
+ // If elements in group move to next address
+        idxBnGroup++;
+
+        // Number of groups of 32 BNs for parallel processing
+        M = (lut_numBnInBnGroups[23]*Z + 31)>>5;
+
+        // Set the offset to each CN within a group in terms of 16 Byte
+        cnOffsetInGroup = (lut_numBnInBnGroups[23]*NR_LDPC_ZMAX)>>5;
+
+        // Set pointers to start of group 2
+        fprintf(fd,"    p_bnProcBuf     = (__m256i*) &bnProcBuf    [%d];\n",lut_startAddrBnGroups[idxBnGroup]);
+        fprintf(fd,"   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [%d];\n",lut_startAddrBnGroups[idxBnGroup]); 
+            
+            // Loop over CNs
+        for (k=0; k<24; k++)
+        {
+        fprintf(fd,"            p_res = &p_bnProcBufRes[%d];\n", k*cnOffsetInGroup);
+        fprintf(fd,"            p_llrRes = (__m256i*) &llrRes  [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+
+          // Loop over BNs
+        fprintf(fd,"            for (int i=0;i<%d;i++) {\n",M);
+        fprintf(fd,"            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[%d + i]);\n",k*cnOffsetInGroup);
+        fprintf(fd,"            p_res++;\n");
+        fprintf(fd,"            p_llrRes++;\n");
+
+         fprintf(fd,"}\n");
+        
+        }
+    }
+
+
+   // =====================================================================
+  
+    
+fprintf(fd,  "// Process group with 25 CNs \n");
+
+
+
+    if (lut_numBnInBnGroups[24] > 0)
+    {
+ // If elements in group move to next address
+        idxBnGroup++;
+
+        // Number of groups of 32 BNs for parallel processing
+        M = (lut_numBnInBnGroups[24]*Z + 31)>>5;
+
+        // Set the offset to each CN within a group in terms of 16 Byte
+        cnOffsetInGroup = (lut_numBnInBnGroups[24]*NR_LDPC_ZMAX)>>5;
+
+        // Set pointers to start of group 2
+        fprintf(fd,"    p_bnProcBuf     = (__m256i*) &bnProcBuf    [%d];\n",lut_startAddrBnGroups[idxBnGroup]);
+        fprintf(fd,"   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [%d];\n",lut_startAddrBnGroups[idxBnGroup]); 
+            
+            // Loop over CNs
+        for (k=0; k<25; k++)
+        {
+        fprintf(fd,"            p_res = &p_bnProcBufRes[%d];\n", k*cnOffsetInGroup);
+        fprintf(fd,"            p_llrRes = (__m256i*) &llrRes  [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+
+          // Loop over BNs
+        fprintf(fd,"            for (int i=0;i<%d;i++) {\n",M);
+        fprintf(fd,"            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[%d + i]);\n",k*cnOffsetInGroup);
+        fprintf(fd,"            p_res++;\n");
+        fprintf(fd,"            p_llrRes++;\n");
+
+         fprintf(fd,"}\n");
+        
+        }
+    }
+
+
+
+   // =====================================================================
+   
+    
+fprintf(fd,  "// Process group with 26 CNs \n");
+
+ 
+
+    if (lut_numBnInBnGroups[25] > 0)
+    {
+ // If elements in group move to next address
+        idxBnGroup++;
+
+        // Number of groups of 32 BNs for parallel processing
+        M = (lut_numBnInBnGroups[25]*Z + 31)>>5;
+
+        // Set the offset to each CN within a group in terms of 16 Byte
+        cnOffsetInGroup = (lut_numBnInBnGroups[25]*NR_LDPC_ZMAX)>>5;
+
+        // Set pointers to start of group 2
+        fprintf(fd,"    p_bnProcBuf     = (__m256i*) &bnProcBuf    [%d];\n",lut_startAddrBnGroups[idxBnGroup]);
+        fprintf(fd,"   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [%d];\n",lut_startAddrBnGroups[idxBnGroup]); 
+            
+            // Loop over CNs
+        for (k=0; k<26; k++)
+        {
+        fprintf(fd,"            p_res = &p_bnProcBufRes[%d];\n", k*cnOffsetInGroup);
+        fprintf(fd,"            p_llrRes = (__m256i*) &llrRes  [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+
+          // Loop over BNs
+        fprintf(fd,"            for (int i=0;i<%d;i++) {\n",M);
+        fprintf(fd,"            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[%d + i]);\n",k*cnOffsetInGroup);
+        fprintf(fd,"            p_res++;\n");
+        fprintf(fd,"            p_llrRes++;\n");
+
+         fprintf(fd,"}\n");
+        
+        }
+    }
+
+
+   // =====================================================================
+
+    
+fprintf(fd,  "// Process group with 27 CNs \n");
+
+ // Process group with 17 CNs
+
+    if (lut_numBnInBnGroups[26] > 0)
+    {
+ // If elements in group move to next address
+        idxBnGroup++;
+
+        // Number of groups of 32 BNs for parallel processing
+        M = (lut_numBnInBnGroups[26]*Z + 31)>>5;
+
+        // Set the offset to each CN within a group in terms of 16 Byte
+        cnOffsetInGroup = (lut_numBnInBnGroups[26]*NR_LDPC_ZMAX)>>5;
+
+        // Set pointers to start of group 2
+        fprintf(fd,"    p_bnProcBuf     = (__m256i*) &bnProcBuf    [%d];\n",lut_startAddrBnGroups[idxBnGroup]);
+        fprintf(fd,"   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [%d];\n",lut_startAddrBnGroups[idxBnGroup]); 
+            
+            // Loop over CNs
+        for (k=0; k<27; k++)
+        {
+        fprintf(fd,"            p_res = &p_bnProcBufRes[%d];\n", k*cnOffsetInGroup);
+        fprintf(fd,"            p_llrRes = (__m256i*) &llrRes  [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+
+          // Loop over BNs
+        fprintf(fd,"            for (int i=0;i<%d;i++) {\n",M);
+        fprintf(fd,"            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[%d + i]);\n",k*cnOffsetInGroup);
+        fprintf(fd,"            p_res++;\n");
+        fprintf(fd,"            p_llrRes++;\n");
+
+         fprintf(fd,"}\n");
+        
+        }
+    }
+
+
+   // =====================================================================
+    
+    
+fprintf(fd,  "// Process group with 28 CNs \n");
+
+ // Process group with 8 CNs
+
+    if (lut_numBnInBnGroups[27] > 0)
+    {
+ // If elements in group move to next address
+        idxBnGroup++;
+
+        // Number of groups of 32 BNs for parallel processing
+        M = (lut_numBnInBnGroups[27]*Z + 31)>>5;
+
+        // Set the offset to each CN within a group in terms of 16 Byte
+        cnOffsetInGroup = (lut_numBnInBnGroups[27]*NR_LDPC_ZMAX)>>5;
+
+        // Set pointers to start of group 2
+        fprintf(fd,"    p_bnProcBuf     = (__m256i*) &bnProcBuf    [%d];\n",lut_startAddrBnGroups[idxBnGroup]);
+        fprintf(fd,"   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [%d];\n",lut_startAddrBnGroups[idxBnGroup]); 
+            
+            // Loop over CNs
+        for (k=0; k<28; k++)
+        {
+        fprintf(fd,"            p_res = &p_bnProcBufRes[%d];\n", k*cnOffsetInGroup);
+        fprintf(fd,"            p_llrRes = (__m256i*) &llrRes  [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+
+          // Loop over BNs
+        fprintf(fd,"            for (int i=0;i<%d;i++) {\n",M);
+        fprintf(fd,"            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[%d + i]);\n",k*cnOffsetInGroup);
+        fprintf(fd,"            p_res++;\n");
+        fprintf(fd,"            p_llrRes++;\n");
+
+         fprintf(fd,"}\n");
+        
+        }
+    }
+
+   // =====================================================================
+  
+fprintf(fd,  "// Process group with 29 CNs \n");
+
+ // Process group with 9 CNs
+
+    if (lut_numBnInBnGroups[28] > 0)
+    {
+ // If elements in group move to next address
+        idxBnGroup++;
+
+        // Number of groups of 32 BNs for parallel processing
+        M = (lut_numBnInBnGroups[28]*Z + 31)>>5;
+
+        // Set the offset to each CN within a group in terms of 16 Byte
+        cnOffsetInGroup = (lut_numBnInBnGroups[28]*NR_LDPC_ZMAX)>>5;
+
+        // Set pointers to start of group 2
+        fprintf(fd,"    p_bnProcBuf     = (__m256i*) &bnProcBuf    [%d];\n",lut_startAddrBnGroups[idxBnGroup]);
+        fprintf(fd,"   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [%d];\n",lut_startAddrBnGroups[idxBnGroup]); 
+            
+            // Loop over CNs
+        for (k=0; k<29; k++)
+        {
+        fprintf(fd,"            p_res = &p_bnProcBufRes[%d];\n", k*cnOffsetInGroup);
+        fprintf(fd,"            p_llrRes = (__m256i*) &llrRes  [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+
+          // Loop over BNs
+        fprintf(fd,"            for (int i=0;i<%d;i++) {\n",M);
+        fprintf(fd,"            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[%d + i]);\n",k*cnOffsetInGroup);
+        fprintf(fd,"            p_res++;\n");
+        fprintf(fd,"            p_llrRes++;\n");
+
+         fprintf(fd,"}\n");
+        
+        }
+    }
+
+
+   // =====================================================================
+
+fprintf(fd,  "// Process group with 30 CNs \n");
+
+ // Process group with 20 CNs
+
+    if (lut_numBnInBnGroups[29] > 0)
+    {
+ // If elements in group move to next address
+        idxBnGroup++;
+
+        // Number of groups of 32 BNs for parallel processing
+        M = (lut_numBnInBnGroups[29]*Z + 31)>>5;
+
+        // Set the offset to each CN within a group in terms of 16 Byte
+        cnOffsetInGroup = (lut_numBnInBnGroups[29]*NR_LDPC_ZMAX)>>5;
+
+        // Set pointers to start of group 2
+        fprintf(fd,"    p_bnProcBuf     = (__m256i*) &bnProcBuf    [%d];\n",lut_startAddrBnGroups[idxBnGroup]);
+        fprintf(fd,"   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [%d];\n",lut_startAddrBnGroups[idxBnGroup]); 
+            
+            // Loop over CNs
+        for (k=0; k<30; k++)
+        {
+        fprintf(fd,"            p_res = &p_bnProcBufRes[%d];\n", k*cnOffsetInGroup);
+        fprintf(fd,"            p_llrRes = (__m256i*) &llrRes  [%d];\n",lut_startAddrBnGroupsLlr[idxBnGroup]);
+
+          // Loop over BNs
+        fprintf(fd,"            for (int i=0;i<%d;i++) {\n",M);
+        fprintf(fd,"            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[%d + i]);\n",k*cnOffsetInGroup);
+        fprintf(fd,"            p_res++;\n");
+        fprintf(fd,"            p_llrRes++;\n");
+
+         fprintf(fd,"}\n");
+        
+        }
+    }
+
+    fprintf(fd,"}\n");
+  fclose(fd);
+}//end of the function  nrLDPC_bnProc_BG1
+
+
+
+
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_bnProc/bnProc_gen_avx2 b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_bnProc/bnProc_gen_avx2
new file mode 100755
index 0000000000000000000000000000000000000000..186ab340072905ed3e4330ccf84de5ef29640809
GIT binary patch
literal 617896
zcmce92bdPs`Tfi`mbwc|S=zD`sZs@{Nm0;6P!Jnp0UO1FsHm7&RuF~Qh#FfgSQ4>g
z5+h1ftf<k5EsD_uqtUg*VAMzwBmZ;mJM-OlE;IAZ?(hHX?DMrb?|pAM=e~32-kI48
zCQsX^!1ujyEAYm7{57Fug4reSo>zB#Q}df|6TFdLQ@r=|dUz%HU2OIdAvPiMxjk?l
zewG^4^9u1<gxAOd*)g(Ug834Dc9Gp)_!*XvpUls06N0bu*<z)j;iu<S8=UD_*77R^
zFTdghvp@ViGAPIO!DpC`Kbfv?kgji#F8tga6fFD<>&LqBb#UPC;DQPG#orV7;Y~8{
z_LH{UX8di*@%%pFVkzf@izl1?;pf5T7yJaDVY&m6j^)g{l?R41gZz@(Wm{0c@H6=7
z4L*6{vAYi+eDd)FPhPm_%%uaDj@*6V?!yP2aq6I9rrz{V+kFo>#N-sVV>N!U%x&?a
z28ciL+c#f2`iV;(+T(yOckK3N!R`zGb=5^o8@}*0^Hv4RHZj&66ZZE?*uPuC{?Q5h
zhb8QvhW*uexmyKx#Fevo!u|mX`#tb*9GiW2?~KK#FI==_o;UB*#V0KC7N5D~4DXm@
zPd$B!H}ANUPd(!VZ{FFbFI<9;z--POCY^J}l4DL^GUt?I7B2GU%$a}6sf&U=bG&`0
zP1$SjIl~4G8#IEYFHnEsFLJ~`^edWRJG0Y51d0Oh2>I!4zf$@cwb>-t$B)X@vY-2y
zKHRF+{#;iC*jMeRZo+Md+8_1>Vk6al=}D4eg4(b9OO4vE%Q-{s5BoMf%~JbqWc0kb
zYJW4y(!AF!|Dv?!(&80A*~P0_v2jUp-E!=%S^jM4Gs*~GcZ@h4COdXng7>m+6Y!0{
z7trX_tvj&oaw31T$v)j|ejm%<Y^qN;n%}een@#lTI`exbf3s;mU1NUl$KPy{Pgk4Y
zd+|4$;?r95do+Ku2|itHeh=esR{hht=68SoW|cpkf!{;_K4sNwN7t<SYt8bHw#_(r
z%BGE*+fMXqHa#`hd~B+EYJyjHHVnU+SJrKk=dC{*4RlD&z{U8eS-!nh&8okhU2xPh
z>*3Ed%r{3pNodE`vTn89x1PU3`=_=S!oFtJ(=|_hHonH+T=UxYGm-c)8rH0MeaSaR
z)vS76(*HF`U%TfGt9F4bTOWdyb?2iXM?GJBF?RW1Kg0H|S-xlGB`{c0l`BHqL!PWg
zl!yI}%}0IuV<ai-=6!kwKIx<8!Y|e!yH(p)J-h(B=B-+BGCpcHO<wnA@4Zm*$?M;i
z&yDZmbNS;m@|HH0F9qj!xpW2hpqTFiHhI?7{IFw3T?O6*tGT}B(rM4FD|_T;#`EPX
z$ioxc=yla5Nih$`H387Sj{)lT;=War->F%C-aFozWl!#k{dKSW53bkat>#i7tDbs{
zarX(T=gBd|2QpCrb;v<82(?Kn5X_%gAel;O*1~^K(K9=t1-7qiPYF!kHlfmd)_EN#
zdY>;66JJa=2PSI*lOZ&j8nlv_Yzs^_2PTtf(l^(BFQEvMe`&6Mo9e#!9u?k%x92B+
z=!G@wmaADEYc?`x|I}kWa!_esKwTBYp@%fp073-{;?YE)8bY5Szc8<^Ip|nIFAKE2
zX8A_H?6=-U8_O=b6wP1u+sPkd&&tUkB3%fU{dRNNBSubT4?ewoW4EWa7q6Q9X4GKS
zW`Co<`Khf<47izoYA$cP0-3V5+t4X4EoV`ls73BMy_BF7$)@YI>7V|)W5=e+AJO5b
zZ{zLK$sd(HIC(Sr9KCMWrt4rDcxC2w$h_<kuk4Y{#<XugRe%*Rz4Q>)<(((yYT#r7
zkt|kfcz?i5MCrCiX{6CN!=&zX1zA2mA#|967#Ss%-yhIeK+7k8<S#$(Bfsq8Zs=K|
zdrMpq4J*V4xhY5^j$kTrfkDHF+y6hgCXV4aLR=4+W+d*rf9JgBBkpCG#uE2y0?EW(
z12}Bib~y@quw@@rP-PApN$3^@Im9go6cAUCMBIV&F<X3)xWY8z2&NJj7&MHyYqsZ_
zI3IBfVVaS+an@@-;woSoOWc3HOC|14fD?%G;4*|9;{K*mImEpLC?KvdiMUfq+->56
z#1*9xM=+JRz@TBo{pnwsiCYKLjKr<5Uh@$*8>X?uO(c-q<9YxN*>QT@z6x@P+f_jh
zajgLb#1$nGcR7ix`_|-4;)>IVBbZ8DV9+q)dY}{;k8$69lbN`eVVdz6cN<J&iCak^
znYe|36NtM)K@M?eD99mh7NCH*;w0kkC2@nr2Z<|5BaUDyae+a@h+Ft|u8H%7%5gBw
z*yAd!*L*#$?w<+7y-FaNxOIRNh<i&x4snku$RX}lKml<jNyNQK;?5EuB(6ysaRgI|
z3k(`Y+`6wa6So4U8Ht;1z2+lsFic~6Tzdk^#C^9dk+?2M8FK0n=PSq|?qfI%h-;EW
z+$SXNamks)m8KC#FqOE#pkc&)_m9lPy$sWg#NB4S<|FPbn8p%!6oF*o#sLo5agK4v
zDaawNMnMj70|5oZl}3r<M53HGlnwxKMdE|RHBBRqU@CEeLBog}_hn|{DqxzCxVpdR
zyyheBahS#ucPD{l;#L4oAnqOoImBJ5AcwdmfCA#0CK1<{#7z|+B(7N+aRgI|3k(`Y
z+=?%9O`Pu-HyfrIi5qOa<|D2Mrm@6*{&^~KF9S{>?kfd3#Qjl04sja*1;jN=BCdwS
zT_rw9T=O*I2&NJj7&MHymp{u)+-)$;NZeW0Yd+$p!Zen+VFZ$UTm|3+;zlaSA+D=}
z9O4Q91;jN^B5nbR+w!T&nZ&h7BaUDyae+a@h^s&;GM*09)nz8`ahPU29k>dnvBaH2
zAep$?fD?$jKtT?1$1BJoZVI4)IIrv?J>_MOaVtq&wfG=$Ez^i2m`Yq=&@kd=f0AqB
ze4%nMOf&YlBI`9@kK6Kb0&yD&BolWV-~{5HSCB*8y$W)OTMZ~6u4Ph>TT9~Riw_dl
zDvdaTsl){a4I}Qhzhx%wESP2_ZmRW~kGN`>#`d@-1d@rX`zVpPmPi?L>Jax&mC7OR
zZ9oBWt&)g)fy6x^K1f_y8gT?ui3<!GMqJ&8nTdNGrWuL5%6iR5+<chE5_bTBWa0(`
z4%u-|2M$({L)<6@ImA@~3WzI9BCd|aefw9FGl?rtBaUDyae+a@h#QPjWIV<d!89Xr
zTRzBn%}3k=FpVYdX9SXoI}30EaX(j(LtL$b9O6y@6cAUQL|o~vAa1PqAaSkJh$EOv
zTwu^J;?CNdYvO#zxT!GBNL;n`nvb|||B^u5djyh+dmL~Aaeq~iL)<0>ImF!uC?KwN
z5^;S=+;Z_j;@YGUM=+JRz@TBoJ^ts+#9al`jKs~iUh@$*7N)U1t|x(H;)(z#5Z6yZ
z4sop%<Pi7u`#Iv;BoS9b;$DIwawc&VX~YpsB`z>%7;!}?MaEFM<-N?rJpj{;rvuAj
z8cW=X1d@rH3OIqd#R_tWJ48VaaiakRJ+2~&xCJDxwfG=$ZPSP&m`Yq=&@ker{wdeQ
z`9ftiOf&YlZ{N*%&DY~zf@v&q4-rTv?kd0u#66-Qhq#**<Pdiupn$lxNyM!rakIn+
ziEEce9KlrL0)vJTch#0$6XzptK1?$bH`aR1M_g-|#uB&vomAqs08Sw82L(CAeW)OZ
zxEBBg#I;KzZY_zsReX@R_G!csOeHQbXc%!@-p)+i12D}<+;ZzRA91r_8cW=G0?9qD
z8gK$}lNIC;*Iz*nab<u4;@T$>_X3Ig_>U%M64xP(ID)Cf1qKZxt{SDtc#Qk@t<1!|
z1k;SixLaWwOWef-l8KuSIDxp!6yy+hnt~kS4h0kt*CC0xIubWfe2}=xG~x)R5*HXW
zjJWx4=9)NPs2mH^j6JTk^_s88ef&lOajy_aChh^i3B<jjAcwg13UY|M8Bjo6WfF0v
z13}yp@j>D`rV&RlmAJs5VZ=S~dS>F5!!#ptv#i&A#0`XLY>#V8Aep#tUrQve6H<np
zI>hZzsT|@y0u&I}F^RaoByNNFAaR}2h$EOvTwu^J;=bLSnYfo=nvu9$t=D|SErDq)
zaYqnHCT=X?kR4~r>lg(&#O<RXhqwWN0^&L)5m!Uv3d9GA>zqa$!BpY`gN6||_SMY9
zwT5X%;y(UE&TBs6Ho!ENxZ4RN6So|20&!~<<Pdkcf*j&b2NV$3If=LhByNiMAaPyN
zh$EOvTwu^J;+DUXYvO#zxLGjGNZdf{H6L*WFpVYd)0b0;dkJs?asN<|L)@DRa)^5r
zP(WOlB;r<*xYgo=#C1(0j$kTrfkDHFd+GO?iMti18HrnBz2+ls3QS{(8$uwt$F&BW
zK-}&Ma)|4!Acr^)P(WPQC~=PA+b@MVZ>l>2-(P$t{m!9-$M0?K96C%sH_paqa6?Vp
zokK?fUXRO@yt-C!Ubp2%G=sUTDE`i&#q=89IkYQ_7Th^>j{tS0+^6mwx)1y7u7=mT
z^YIoop}lix1M#mFWbYi>Oz54Y0`cyTI>}VZzX+C*JBKz8!c8N%b7;+A^I11{$X@Q9
zL)!wAYCtfpTSJrRokQi4dfSA+WF1ZHokLS5gzfi-7sC2&s{0kb*Ikac_&bLdAW_{9
zIeUHQ&`LrdD#+eBbT6S76lCvId4bUV3bHq#{FTsE0<rfu?wv#4M5ULPH>LIdk=pb&
zm?roBrP}l?>ounLuhphgVH)=Str{3cAkzCw_fiF~031r!-Z?Y_CUqkfWcip+sH=i(
zr@oL-0idAwC*C=95e>IIZ*nGajeF-%gt!WnB6%_(LR{T*nTdNGrpc255#p|bX)JN)
z5J)C&HsFvrJHox4Eqj52Y}j5;=y(M=#7zMd5SMu8&};NjEj~zG<K8(GA#V1wxh9So
zC`E`H4AYD~uE=`L*W<Q4lR(@?0?EYP1~`GZ=N04-cdvpR;#LC+h)cY4=pQ6*zW5+<
zjeF-%gt*(D&P?1{FwIEZRO>Y#an&%5?Qu;ABokNnR3dRLkuv1eA?}|ll|$UyfCAzY
z?;L8mH;8*ce2}=ty>lo+T;0aZ#61qvjKp1Kz2+lsK1^eYJAgnkaf1Pe>^PzFU<EnE
zjZ%<9Tos^zxWqe$29UUKpENm>xW>J6C_>y|lp^CXt_Y?XiQDo-&TBs69)M{qaX%xF
zOx#(36Nvk{f*j&%732_i0-%7n#5;$kkhrnpgTyuNokJ1g&U!r8#QBbKQ(>BsxN7S)
zA93IQE`hlB2qY8tIN${0{;D8{xJ?Rjh`SF^KwRRTL-R@8a`8dp8u!kj2yu^Z$V}W-
zFwIEZeCstIabsZ`+v9o?NG7fbZ~}4t6yy-sN<j{BUq6;3F7eKxl_c&Z7$Rp9*SL2M
zMTjdxDKdu2Estg<?g5x)JRMjL(^%q8B#=zpRKN+uEmn|2+#w2bh#L(k=y8d64y`3|
zt;Gk4Yur1BBE(HypKIcLp|TpL8GGEfkL0}O>v1o^G?uuB2qY7C72pKo9#N1(+)WB{
zh`SI_KwRRTLoblHS>l7lHSV255#p};ZLW#)5jP*E8HpQfz2+mXHB4iP+x~DWaa#Z<
z5ch+E9O6DykVD)HfCAzY?;NTlakq*O64$tQ4n>ID@|(=WJpj{;#4Wd8^AR@-rm@70
zCy?CZssSeuH(5aras3tK5LX5$ATIIFq0&hp?&DvZoJm~c-Z>N@t{SDtc#Qk@SDA@>
z38op3aks)Wmbi-vBoj9uZ~}3cDaax2GzB@t9SSHQF7eKxz9ep-_#knOd*@JuxcLv|
znmAvm91GKoJ+8I&ny<%wye@&bR|q5%_W<Ao;@(h@L)>}=ImF!zC?GEJ&Y>C-w?ur9
zxW>J6C_>x=4`wEAIZQJWH_Lj>N8CV|#`d_j1d@sS_JKs=Iw57qsYBcjmC7ORBR~Oh
ziFXbyAaNVS2Z?LkJBK2~eS3dq;$DJjM&fR@Uh@&R1g5dX9YG+OxUqmkcAP1%V-(~N
zw~vAx;syW;h)cY4XeEg&5FaG2aqk?85I6R|%*3^ZX-48czBlJJA8{LC8cW>m1d@qc
z4mg3hwF+{GyIesIai;?ch)cY4Xf27GB0fl5<K8(GA#V9SxhBqcjGG11jKmGJUh@%G
z0Ml6FKD|4YxR(GY5cdxSImErGAcwd|0R_Y*-Z}IFiCZl`NL=IIITRu8rL~!fyA`Gx
ziCbd5<|A$jOk;@~LLj-vwFaC(-0li;i0iB%hd2*VKwRRTLv<wX?Ym6QB(8Dq9EuRv
z8l}j1I`Hu?GZVJ~rWsEMR>L%wxU&f)6E_QR0&(Xl$RX}n1v$j+3n(Bi@y?;r$sn#u
ze2}=ty>lo++^k>ZnmAvm90=2lJ+8od&DZ1JzB7TiCkP}HcProo;+|EIL)_g8a)`SE
zP(Yk>=a7A*abFU5g7_eDjeF-%gt%Mp$V}W4m}VqyiuIb0xGI>&_PAmK$;5qpdm?eo
zkuv1eA#R&W<q-E4pn$l<JBMmW+<oGM#5L}nLlNRWzAZCx8(^A|xYgEcKH^S*X)JNm
z2qY6X5OBzjb2>0nK@M?yD99nM3!s3w#5;!;khrhcn4C#m<K8(GA#NZ_k?|N;0Mm@b
zy?txWYd+%cgJ~>rR})AkZVBK7;%-ooL)`faa)>()P(WPbokJ^0+-UJZ;u`nPp$KtH
zZpk%qzGK`Jm}Vrd%6iR5+}AfJ5ce*DWa2geP9Scpf*j(WQ;<X4J%9q@67L*ZOX4mR
zA0)1E?;MH{x8bJD#I1&DM&eGeUh@$*8m6&5t~-Hb;tBvK5Z6aR4sk6M<Pi7O&vV2j
z-Z}IFiF*Nt$eF}7?wvys;tEiTjG^-F8#5DkA51fz4qOP+SmG8CNG5Iy-~{3pDaax2
zAO$(ZjRX|*xWqe$>PTFf_#knOd*@JuxG6W}nmAvmtb%FA9{2V2Ij{M8+zT*`CGJ52
z$;7P&oIu>e3UY|MQ9%xI7XS)~OT2TabRQ6RsQ4gpjeF-%gt*n$<(fDjaVNkuBXOgx
z*L=j4!8De*e_fkO+}nT?i2Gha4sjnS$RX}|Kml=ycMh4G3~tW(*i_dY-}Bu$^yXoc
z%$-AT%jd>-@tJbx(EEVbn>&Zz{2A_cxfO3|cMff%*YM7vf5NyXxN~UGECba2f&0{*
zLqo8??r^%EL?rmfE%wf#@x&ihkiB#0U_!S5iY*ZD99k@yO8JMwGIHn8x_!+(RNE#@
zF`sqbetWxj4s8xh)&wR)XcE11Xj@>iIWU<-6MN^-XDEW?f6X;v{WjGt#rL{{@TTt^
z;y-K)o*#WUYW8f-{;9|8x%)^$cPpqzF4ZhTS18D)swH%Wf_mmstsyi^LH1UpX9?}8
zAbY>j2ZVYEv_0`=!sLUeH(TlC#;a3%y*547n#OeH#oBaIs_9y7+A-C1t2X`eDjOgw
zk5H9(3qUB}5xLf_fl1we6vY1qC?wYs`b#Xdk<haWvJSl?0o|>ju{nn$30<L}F*#@{
zp)(X@9j+%dOF^S@skRZ?Q$gc$(2%15^-z$#E9z82O%!A!+bTj|{M0s-71U*fUK5B1
zq3{N_vyqxI`oI3`tD;qtH)oV%bCe=^fELl%*41gI5#c-x)9}a=5zb8jLg6^-cq$e$
z>i8uf9RB!!**;$y9Z{@9Q|4muIOSqwj=pVd?c)GNQw}*=r7Vg~xfCXK{Qw0AC;zNv
zVd3}8xnEDC`1B^{Pp`C9o|sFuovHqyAY0xEa{&EXL5@hTSCAvp^AzNW^jHNsBHdR(
zR;1^!7`qBYk%l+x#fr26|K_V6BAs_dn(`td9g}Jr5otM0Ly=yO%I0MB-Q|`s+x9Q8
zJ-Q%GC;=OcO6LOd0VRmE26)c<4a)oQoE}!v#S?&{BHgG{&QU3CO!JOG%8LL6A}z2Y
zwS^x^Bc0yKd6IH%rM;A?`YFh!T2H8zf^31d5&HTv+fa^3-%*ew(#I9#i1c;^S&{ZW
z7I|GF5Jei^m>4V42K-C2dWiI?OEZh~+EmksNKb-ktVm}92$g7gHX=P+L5@g|1e8Uj
z-~7aSx1<}9c4UbnXLS*gJ{Fs@hCKZRP$1I6M3Kg)H#y&`TstDYNI|x|Mx+ZB<cRbD
z1vw(!O+k)GD;4C3^na^tvssaz$IAazAc{1+2{Trt4fywM^$=+nlp^Ed{;QQ~rV)`o
z57StY-VY!_q^~Q;5$Pj<vWRrLa$!j~Qdt5hMWpRwQyP(u1{8?2C{d*G=}pf6xx`l4
z5$RtPWXo$r`mBN+k>0H!N2FIM$Pwuo3UWj`OF>qoKc`6d6o?`XZ#az=X#@UMT|Gp4
z_Qh$+iyZE!rJ6=W+8w5`A}s}wAku*fazxq&P!^Hiv%-3}q#LQc3MfUSi(^w7k^T%&
zAkyMQk;bPtIUk~2J0cyeAX{D|(ryZJL|UXEN2H%#WE;Q{=^qs2i1gPAvLbzyBE4Q9
ziZr~rHddq!__uuZ5b5j7GmG@DRMUt^&xL8MNRI=MAkvizazuIxpe!OSRxT{*Mk@UQ
zrHJ(R%WS!9N+Z&3fC7=0B#JaXy~%l<a_xxpX9}{p8j=1;L5@i0D991%Bn3Gl?WZ6|
zq^%TWMfx^H`t^mTT`1D<M&ekJ2LE9&`5#*c2I}Ed^$_Vmlp^Edz97{!BGR{O6GZw1
zfCQ0#s31qAF96CS(z(ioCEZA61)vm>_Kr<yL^>5vAkrp@B8^XPa&E3%J0jh7fo%<2
zUL(@C6y%8XF$Fmyy;VVuNH0>5BhrNmvLgMKB0WGLiZr}wI##3&_;-u-5b4VEGmG@7
zRMUt^hru*9l6C};AkuLPazxq_P!^GHIL~^wq#LPh1(YJv3u99nk^T};AkxxAk;bPt
zInPtB9g$8|kS(tf=@11uB5kK2N2LEb*EWD7(!VIk5$UrEs>)4@R2~PB-YpPC8r~ot
zE7Au1Ysq?u^ur%#7U}v_(}+kfhiR-xmjFl*=?w~UM0!4;EFx{MTv*bLRK@^G5$StB
zvgNWVjYxf@3`E*AQKa$dP0mj#*N#YksUVxH5$UB0azwgVL5@fdQII3j(F$@z+D$=L
zq$4TPB7rE<@Mic}kv8DpXx2ld<Ic$}(u!2mh)C;}T9HO3^IruJiqtYTi|z4^f+pnp
z^Yw(b07?*PWHSFW<-$&mn<@2c0Yya`natlKHl>-&KN3(N(q>kqw(w>$KR&(5xr=h`
zOy>IvvgI|C`5&Kc8){UpHOz|B?-k^Tbe)16k^W3Uj!1u`AS=?XZ236?QKaFG|FI%%
zz`qQwhe&TYE3-%!rJ6=Wx;IS2NE#7oe*g(0ovt89q{9Ja5$VfkTJM&0BbBcJrHJ&Z
z*px=3j{pip+B{LD@##&@XDio^NRL#IEw2&jL<Kn_?X4h3q|FuNh;-W$+cu6!-%^kj
zsdqd?`j|izY50(XSdlj1-=o$;q~Dy8S)?zfnnpx=3rs_iMpm3w00>2D+uls(-=iSs
zaDOGB1d-P0b)!DYg*|+lgYGmyQISR_^Z$OjEtfsIniZ!uNEwK<g%znS{79|>>GV#{
zuPfI!{w`&zM-*gJnZx}}3bF+<D^3?G$Pwv01vw&}svt+CLlk61T1}C*6Nn-WALtM(
z(gyr1*m{U``e~U(+AGyGBGP{^P7vu<00|;3hWik5MEV(0WfAEz<=v8QM0yuXl)U0p
z6PwbENlyV3h_q#*NaNF+oChk`j!4@m$d=cL^t)4SYd9i(PeG1IpHh$`(qAgb5$UB0
zvLc;8kuDa9A`Ks25i8OL{M*}li1eOCnMHa*s%b=|2g5Wrl8yloD$xcb6G`VP$Pwve
zKv_ik{wdbGCEZA+fF(*6=^e2tjYwYr6o|A{qDbS@o19lF*N#X}QIIXK5$Q|?IU?Od
zL5@hfD9911uOLUHAD?WS&5Cp`Mf!VzDAMpj9kC*9z`yvdhe(T2ij4E5@1B%q8WHJ(
zFpU-IwEz-Cx<NsXNY?<$BGQq{g(clc<tRWYBK_e+TP~Z@h_okC1|ls>6lr{Vlk<nl
zwIk9O6l8NXBE4Thj!3UkkR#Hw737HYNCi0}ov0uy(prkNw?GtW_)wBqkp};*IC(NZ
zFlg9h{@jIW%8M+Ejz~3)h_o3@V@3Ma0xJe5lD0>hP`{2y|BF;vM0&OIZb>&%Sq~^h
zq=(0*G$K78P$1IsM3Kg)H#v_}t{su~RFEyN5oxJ{9FhKgzHKN+q^~Q;5$PieazuKQ
zf~-i_P^1?MM3IIMV2KrJ1O9b$JtFCbd6`AJI@L5H(i31BE7EBILM1vPJxxK5NDl>+
zMWkPzV7*(?jZ`XFqU6K<Z(>s#k!}GLh_rR0NaNF+oNrLB9g&`|AX{D|(&H55h_psQ
zjz|Y8$PsB91vw)9?s(g5R-_v#()R?SNW+KC#EP^5|E9VgB5jXSWIWt|eq5SqM5G&G
z8Y|Mf03?X?Wd%7ReF#t%kxo%AEa^rnivXpFv@ABI5$SM1fk@jViZnjG$@!aOZIvC7
zZc&geuMz1J3UWkxhk_iDu2hgC(o+=Vh;*ictVp*~q<aWNk%kY}i4|!B{v~%kM0(mW
zY08Tn?)OPGjfk`}Ok+h_03bo6eH7$~v<09nBE562^=?TwQh5<jibzk4O=(1WC7?j0
z6^SB^Pj7Obu3S4J9j+i-UL(?u3UWmH!yH>nN2DJr$Pwua3UWkxzk;kty%QkPs|2D*
z!-ojPinIa$e!Lzcefj9jBE2ouG$PWoU>b@vGMRrAfKa5CF|*>dOhL|M{(L|QB3-9%
zAK7t~^=>D}&6IjCmMC(#kE}R77n{;d=6?n#5NTU0Qd@Yl;uN3W<b02E?M&uhsUTZk
zGnv0cL3UhZR-6u3kR#G@3UWl+Q$dbMOBG~AT1}Du{YcZI6lwUtq*#$Q;9srRL!^CB
zij0T*?~h0`jfnI$n8u29J%9v}zONuhq)!9NBGTE)g(clc<pMw{BCU>1X+%01P$1HF
zi6V_pZ*neHt{stnHruv_Ew2&js|s>N`Wpo~BE3ODj!4f}kR#IL6l8A|oj{S+2t<*F
z4~L2sX#@VPd_6?E?C><@MGp6erJ6=Wx+_dWkw#XWDgcBcwQX<aNk=NkIox*zlpxX?
zz2fxnEbHAKKFvY*T|iNhMpm4DtWw&et66bc11Jz_dn-~~_>o*Y(&?R?=PK7W{w`&z
z$qKTm%;CPjf^31zic^__9Fcx=m~8+@q+1l^i1Y~s*+@E<BE3T(iZpx>R;)+~rv9_j
zz@TAMQ12g_S){*8HI0b$5}3w{bP<3AkzTDJN2E&uWf5t)a$!j~A{_xJMWlZ`#FopZ
zG-J~L0t!UhAyK69=}pcXlxs(%YZPR2H6mT1AV;JpD##J(bOkvg9j+ipq#YGxMOsUd
z{&28q7m74|=vS;r38soPFld-aN1_xN5BDuoO(P=x>p=-3eGx!{NWWB&BhohjWfAE~
z%7rD}NM$vk6p;>%O=(1WD4;;3m5CyaPj7N=uUtDK{qIcM8n(Pfq+1o_i1axHIU>DB
zL5@hTRFEUmB?_`4T|<!`E)Yc;KHw}?qy$q%8W=Q8q*ou9S)>b6O(P=R6Q;3|v=@K`
zkxo&NBho>DvWWEg8P>Zc-ALtgKq(@<EH<SP=|g}5k#<ZJX?%K<^J&VpBho_^WXo$r
zIz~Z`NUIg(h_qNijz~Y7ZrjEY>8lE|BHc)l{zf2*G<=v_tVju_iZn22m`J}oAhSrH
zNi~g#^m>@aiu3{i2_n5yL5@gQ0m>rM?#hKF-AH90Kq(^qWPe*Oo6?B11yTkg?UX3e
z`1B^{mz8Trqz@^`=4wQGt%4kp{#ZedNarfZ5$R+FIU?<^AS=?X6ls}26lwV2x>%7C
zOciNh&@hosnU-0kRjH;Ck$ycjL8R{jND%1`1vw)92v8Q0o~v9~(v4JZ1C%1ty<$@u
zk<JGch_rK}NaNF+ock!(j!0W5$d=cL^sD`BLpdV-qk<ffZcvaT(lrWlM7lyjR;1oM
zi1b8(DAMpDeX$}Xm@3l1pkX4tb4q5Bo|9@C5$ORijg6!u03?WXwt^gyjt7)Qq;J<)
z@0N5UmG1$ii1g;zlt!da0}4diB~hgD=}pedlxs(%^A%*vYeYItL5@g=D##IOdj&Zn
z{qMfEZ5)wqRge{FHAVWIKon{CK*Cs&5=<3oV9+p;?${@@NZ(8~jfnJan8u29HGl+>
zKCB=|q&EV}BGO^Xg(clc<uE`gBHcdOmdmCzBJGNlfk?Y1iZnjG$@zWd+7ao~3bMHx
zk=~^sN2Hf2$Pwvj3UWkxsDd1kj!A~9bI_)`J16BHzPS90#q%~zUR~hf{i;H~UsJ^Q
zYm51QeF@)hY{K`OO8I_EQ@*ch#`oKs^Zm{ieE(%jzOQY?_j}6teqTA?A85n(b#3|n
ztM+{VO(oxd+llY%yYT(7D!%`&n(t5a;`_$Fe1CdZzCSyJ@6QkC`wJua{?b^!zdV8O
zf2iU6<{5l{eHP!}oXht=F5vq+i~0WUQog@e%lAL8=KIz)eE;h@zJIil?;mgGd)-#P
zf3}V9UwA&=zpUo_wh4Uy=Ul#jQ|oV<{5|di@;+a1>E!Qgt}lCJ(&W`;k8FH``&MnL
zI}#tUK&$(y+?W&_mL>oTK-BWd-}}qY`+nH@SFL9Tc^{g2_GEczrhIOE7oTYl%>-=x
z*4?@n9`tx3-eR9o89W<v8@+}P&3qijHQ_@uml~k%2JX`j&BXq?UUXeXWao!w62C}6
z>Y<s076OVbka=jPWGdy~F%fO`_<|ifc6euYs@XJo`;7T`ZWp+#USK}!w&L^iMPlNM
z$>P9dO<+>J5GK)wX08rQHU=g`Xks6l`6-GZ`OiWAQol`gd*gdu72Xmant2Xtc4f{!
z^3Y5|OBB=toXb-fXAwGFL3Smime4o_sfT6~>ZzbEIfu^@DpgR|9P|O9zfUkVYS2S7
zf24GB0{jG1dU21+)uyAZY1~6IwP{(Z=~`|2(fC{eV!UqErjNojJl<9QSXE*TfKa|R
zjMu=V?l}di$08ECCl=aB=t>1yhu*n>mMF*`Kt~cfTtVugnS{nE$U0n4sHcKP<w)K}
zs8m7f7<3+>zmKz3R>vShuPaC$g9tsMAS<ZL2;C$Q2TG0n&`eG7ANNdC!(wfEZ>niT
zIJGd170!GBp>P~^Towx%b({t$VW6}QO___qO_ht0mRYv;AVAT9(vb62%2&tQa@mwi
zVN&-EpkSaB|Ikbt#i!rKoPVQSs|97Ix<NrU*9jK@I$uGKNRLyHBhnfLIU*gXAV;Ka
z6l6tu4vX>K7}G8kX(K;0Q!8&MN|CY*qD@OuO(P=x(`YNw>rvU9jGhJ%iqy9K3v7>1
z6l8-@X)U0a0VRmE26)c<@ydlA9j~N|Re+)*-KbOcS1D~w^Dacn>3{-}#y>QZMmoKd
zbD46zXRhZgWvXvR+19YB))U&IAX}hqgq~24Bhot*<cM^of*g^aq97~M-pi2JOo1rU
zMt*3fR^DYJGmG??RMUt^cZX>hNh2cd3LrtGdnw2fX&*pYMEc|&*1IL$i1Z^sDI#4F
zo3e&H-2*5PY5YSoDV+H9Cg&5CYe%Hh6=ch6L^@nSjz~Ky$PwueyW0kEMEaqE9Fe}D
zAS=@ISo!+}qDUM0p_y8wpNz;X(%+?;Mnw8kn8u29DS!l#-mD-;q{{$h5osso!jf*J
zG9FNhNVg8R<+3S_NQ;p&5NZ5FGbz&e^d{%$lxs(%_bABbYD9Xaf*g@9QII3j!xiL+
zbew`5k@i%O73t3@(o%sa(nfx0rWWa5yJZ$>hg8#uNWU1CAksGgB#3mof*g^)4=9UB
z&r~if=|(Cy0!k6-nAns?q;mlUB8`7&CPf;b-sD`ZTstByR*)^P5$R_`Z9_RCeN{n@
zNPnXsN2E6>$PwxJ3bG=7lp;M&Ad0k+ADXE}dh?LXB0W9TG$PV{VHz7r2LVVB=|Ku|
zL^={s7LjfqY`t63ja0q`lp@k=V^bQDZU7XBH2$HP6lr{Vlk<<2Ye%GW6=ch6L^@eP
zj!63}$PsCof*g^4Gsw1$BhoDjvLbz(B7H(2inNg*nyE#)ePCvhzLIJh5$WwPjTPxC
z00|;}KtYa3uLhJwqyv--OS+ND3_vL&{c2ZRE}PPbv^`P=B8`7&CPf;b-sJp8<=PSH
z1_jw%jY!uh$PwuZ1vw%;Q9+JKrz^-2>2L*Ek$y{&b`*#rZRCe$YLOl^AhSsOrkX}X
z`oI1OBK-(Jf=HXfeF!-s{Sv9Ni1cFR-I8vkaxY61x$!1)c0VmPr4i|AfC7=mKQxmf
zjZbfK9;#eBB5kiATV5m5|Ms)3;fQprf*g@Pryxh9_bA8_>6Hqq%FRDiE=RqV2t<)K
z@<TJVNFV5%S)|KTO(P<m1=H9_Ivzl%#8J8SFjG*+E65S)6hK)-`avJ--I8vkQo<4?
zi}bG8lt!d40}4bM|Ikc|G(Nq_`7-6&5$S0PvgI`*Jyb!CNXID15oxu89FZ0)$Pwvh
zy=}8uk&dKDUloWVZRCe$YLPZYDKgHJ{&|-)(}+la4bxDhkyW4@0fZv8jLl+uJgJ}w
zIsINw=uSWhB8^Puk5w-0<hYqqKL$`#q>;(|g4mR1GQSU?K&0^x&E&Lve0r1fC%tTy
zoyq){6=ch6Ci5RsknPQ8#pzlFIU@bBf*g^~Rgfdn$qKR}-O85lFAzoA$PdlbB0aum
zn(`tmPNPyyBO+}D(^!#y+ru*Eh_n;Zg!*+vx&x`Qi1a$;-I8vk@;g8&B0VZLr4i{e
zK!Hf(ADT&##-}$q@1<NjBJHCfTV5m577B7i`c-$^P>x9ds31qA8x-V-bd7?nNWF_t
zuN4AOq>cR0OfAwUt22xAnpD$>NEgC16lr8Ke+Gb1iMH*{;r>hoIfwh%fD%Mnqt}i8
z+0A;lhfj0R?Z6TxAMV$yl=kRqR-E1k6o@qbp_x3~>-0{}H!Ih+UoK^;WeT#X%;A2%
zf^31ziqkX&IU*gZAV;L_737HYzg4!`tVpXV(yanfq>cR0OfAw*C`HD@{Xe><nMOqV
zEKFlXdM|(kk#1IyBhrTfWfAHA%7rD}i1c(oDI%?iO=-rYBLM{>jelq+<rbgb<h;F$
zt+FH1_Z4KzYef3Af*g_Fr65P7mnp~*>1hgbM0%)#tVkzNq+<l4NE`W~nOdZ0c1}}X
z<Z!=Vs%b=|-C!Ck(h>j(A|0S0N2KL|vWRqTC+ppkZlv-GpcIiVicM)mdNrUxr11~U
zq)6k_o170)t{st%RFEyN5ouQiIU+4kkR#GhI@$(sMEbIV9FabxAS=?j6zR1BQKXIh
z&`d4T&6Sx&`ioT4h)90~(^!!n10X@97c0mS=}CaHh_q0-u%sKQ^aYe6(ic0}a@mwd
zq+bFGL>m9lOo}u<y~+6j<=PSH)e5q?8j&tlkR#Hg6y%6>F9kUw?V}(^q%9O=MOsUd
ze%0Qz3q{(<56#pf9e`3~JluP!rV)|8)h<D#zXOmU(hn5mi1c|tSwwoYa$!j~Qdtft
zMWnrAQyP&@0ThTd{-K!^X?%K<b5rHo5$Tt0ZEM)_8j-%CAV;L@737HYW(7GSU8W#M
zr1KSIMY@I}ohA@P+Q<*h)FQpOBC|-3NHvX!bO=miBWVW!2_hY<AV;L#0c8>Cqiw8r
zOS+NDp8=(a^n%!wMx=KF3Pc+J&`gRnKE28Lc;(s==@bRo@*0s2QjjCk3I#bL-QL<Z
zfFsiP737HYX$4u4Zlp->5{M#g<cDTzk$zB~S){*BHI0b$Qkcey^mG6TBE3#Qj!4f1
zltrX%l?zL{k;*7QDI$Hh%$CchG$P#rC=hA<Lo+GT`1B^{CzWeQq<1RF=4wQ`N<ofD
z7b(aQ=|Ku|L^@JIj!3&I$cl6;MOq*bMcT*@&D0_t+bXk2Tc?^vMEY^d1d+Z1AVH-6
zRFEUmw*h4l>8Z+vCEZBn8bB!`9TA(-h;%lfK&0^x&7?@<)0><-Dc6ojceJprVasbo
z`jLVhk-n%PN2CuZ$Pww)3UWlcR6$mx-U`&~D1j)_Mt*3f7U^}(GmG@(RMUt^C&Dz0
zq>&Y;z5qgzTE@(Z)BXx_Ci8~@N)YKfef!8u&8&AjIc}!Z{{bi}(#VR_>e!TKGXG&f
zfk@*Yn#sxh`1B^{GnH#+GJm#$Y<bOO{&)qA%B{bd6{lVbazxrxL5@hjY--!a5$PKW
zvLdafNY@KQkv8%}Gqp(nS(;g-n^H|9BE1Qwu_9d#AVH*S737HYazI%`x{GpQNjFm2
z4^WCoKW}2oWm6iFmLp{#()fpFQl#<eP0pK@Ye%FHE6C<*M0%rw9Fbn2AV;LfE65S)
z6a_gV9i$+8tLOxZv_c??w2>d0sYSYfNoJAuNHvX!^t)m!(#VR_p8<p-wQX-!oC@JS
zgq*{D9a1HTv_`Ku)hh4y@M#XZzhH@ySDf}yDeckKtT>$nC=hA<Lo<1}*Xf;{2PoI}
z;IWjc$`xc&nZy0JMYc6;fy|22y9#nd`lNy!k>05wN2IG1WFzTZigb}c6lo(rG*gRo
zZDD4So|kGG5$Q~rhLJQP(oq0HB|0KKT0xFT_Xd<jq<<=~-Yw}yq#jF@EYjOzQ<^d9
z^MC@8#y>QZa*I!Ia=uu(c0_uTf^2z>NM|U>5$Om8IU?<(AV;J-eA_mTNIz1L6=^L+
z`l3J-X(K;0Q;W0^rN}r>`i_@o8WHLJFpU-IH2@Ms`lx~&k=_C*i%54@E-dLrDn|fH
z5$X3ke#n)}rZgh$j+B8&;~$zyk;bPtIe(yBJ0g8vK{i(-(t8!;h;+4r9Fd->AV;LL
z737F?yn?Jq*HEOr1fobA`JtIwq(}eoLspUQmTDRiX(>!&Mf#8bSur?~v@Ozv`gKJ5
zZ=}j1(w{2tmUJVP-vUYz>0z-cjY!W06o@qbp_vqEe0r1fSmoLgX?F$L@*0trD991%
z=il3gazwgWL5@ftR*)mo8x>?lx{)HiKp={=ksq3=Mf&J}GmG?!RMUt^kArEfNcRH}
zD$x<?sS0vLdN80YBK_h&*1IL$NToGPlzh1VRcuNl(zgKxB8`7&CPf;b-sF6pa_xxp
zTm{+k8j&8OAV;M8D991%00lWBEmx2u(r^E5o6U-JD@FRQKon^sKQvQ|v@J@J@o@j?
z_B7LoNS}adtVn+WAVH)rDaaA&gMhM#bYJDdl5V7OGN2TZwv0__L^=#mAkz4UW>Tc_
z=}pf6{LWU{5$W3svgI`*{hfjwk=~{tN2C`k$PwvD3UWj`LqS%g-o>cb2!SZlMt*3f
z7U`+~N>g6sDyT`RrV){LglViuJpc(J-9<r;NSgu5BGTKxwcai1Mk<>CrHFJvY)T{2
z%K-%<jelq+MH-*p<h;Lf?TB=kf^2z>NINLV5$X5e*jhRw{XjvENS{}bBhq^nWJOv{
zk**eqB5mY{W@?eX^mS&D-kNF}5$O_`#)|X^00|<kRgfdn698oq>Hq#|y<5_aRC=&P
z$%p%AVpAHC)&UAc8voEtiZnjG$$71E?TGYp1=;c%k)Ey~N2G@-$PwvS1vw(^t{_LG
zCCSj|Uxh8YsqR#KfAN`lgUY&Hgw+MlE9>S>JZ$2s9TN|ovg%(G51F#+t%(OuyL^}H
z&*|kIQgiu0ejYTf-`|G*sphHw71k{OqO|U<ZSc0@?@Ove7t>aKHf`0vCc(#!w(r#}
zf5xvF_4%2f)hvIu^oXM-9y#%-iAPVI^UP|S<=4-69zD?lU-NFh$EyC{w%Q`ktL=f;
z-FSTkU%h?L8;957crC!o-8y5()v*1e*w;4oy~3j6k|w21n^pM5ZAyy^3j89bD-6HT
z19I`asxD2MH!Uh{QQD+Mvlh*pHEGtYWs}n8Es9G@h<aX&=0(NDa8_Jcf(`G*CGcEQ
zSQu2ZxTr90D<~*n2}+xlv~7w^z0xLpN8=O}wC~WYxVTl5mL;W4%bT`nRbEh3R8mq3
z=PiqyloS^f78aR5l$rVW_dMS(C@S=^*QvP=e_m6+xUfknEqw>(KI|=Q7Y_*R^~Ps`
zk1XH~hT=n|XoE8Q#j+!Z2Wk0HSXf+$wDsG@!+bKhnugcWc&)_iKJ0r8uYcitAK$Az
z6;7Aqb$@-G=PycaOXN`wyFPf0!uM0~dKllIm$bFWvbGt%FU0Fq*{9ye*G};ELiwlG
zPWKM<4y!$)_89ND+T)c)>R04mR@>g|T)Ru{P;WQn<a;HxyO^?s=};!G2CoBw9)Z_<
zyq4khQ@rlL{zve78LyA<DsDjgu)pxw2yvkdh67XAGx42V+zd=@wd{{*Gp`q3yW<7!
zQnpdv*xEfkv{LQf-sIYSyqel6Xe)4?uywBOQrpezUfb8}Upv4XSUU*06?sj;P&=>E
zO#_jpZmzxi`+_`Ms`Ct>n_qo@=P6!ZSk%B!gT84pFEF2lW=~V|y}8#ENRini@jA3G
z#{L42(r;nVwq7fIuk_mI?2A1H#!`c}^sIfASAqTgjYKNFA;z97fGv%ETYP$6_Za&b
z*k9?f^Gxs{b+4<j-__d%-=}y3@jlv=XP!a(dty)VPw?I__KaY=dWYa$?C&x5|MEV^
z9!5|4oQLn1dF<k!davO9X0vCS&ppwN?Zz-D?HKnhYVZCkK>OJ?<u}>GcFndG8V^4B
zk*&~tqgN?Yx|d>D7X^8i7`6-0qQ&^jmOk`Omi2~1nEsjgotkTc{EP8Ut&||&BBU+E
zx3ETuiA~xf@Ye+TYX&bRcrSrki}9P^vuv%9PYe7tK{_h5DgK%xVRO?O`8<%ZDC^`y
z_DO$A_rRL_crg`w7=LpQ`OlJ`eT((>O|22$@w*7`O|Z}9B(5YaP|xP@z!JAaj%<Yz
z(;m`i<I?DTj0_l6?37o5*IJt;elJAsZIF98-pi4uHOf(h*ieXXWr?XQ&=%I@zhjR7
z3Pc~_pU>&ex0Ru{lmE_0Rf!g8i}(8RFTI74jr_6Y*_!0ANxsa1hsr1a&5%a;XUc5+
zH$%Ho>*Sy9CH$A6^|JEc(ePgm51o-p`0oUt?Xf5SCj56st3|g0uV-{e!Y}gQ7pZ#(
z{P*!XpdI^V=6?_dCc=L&v{*I14@AkknKr>tCGR%S8-x7%V^}vFr5NB1!+@nJ@~=X<
zy5~(T%4gJIySG5fmWKak_}#P~{8Q`Xza@^J^u=RiK_>l^|7x!jhCW@5eMheg>d_O&
z!)*NbMbBaXFGu>$XuF;$cM1IUMJsmAP=6kAJ*2EOM{=7WJO6ta{%3mQys_S%-a+2p
z;NuW)Ftj+vx=Z|atTz+wHpbf@`4@NxEB;4&+4-Lb{ud+leDHsI!2iD9QHi-)pd(tV
zD_XxD`0s+0U7_Cs!$(&ByF#t4F`O^(dVsZ%|4R7C690x_yi<+Si;(|`-Xx54$p0Yx
z<=^Jwq+xI5U4xPz1pbde9mXN=x!wU8`L99RDE~Ya$;$r`-j!Z0+J2^YZI1sV!T%-o
z;{Ohe)h<JxA^(@4FW&CmkiYugFHHacv-gl!hf}2a-aUr@+tB~(%YR?R|7h^hG;)fT
zRFncJcY478OvC>O)Bm&c{}aRi31F)Xqh0d9+B*ZD&c|Q=ZL{J3bo_&e%e`j||L1rQ
zct5EZ|L=hRwdjAV@y9LXUw);R;RtWMKg6&0XL|eiUwD5v{lA4T{BuN}Z|msogPODd
zE%1&E`rlsOkLuO_4|=CTZw1gG``^#J6VQH3GxopNz5af+_gAC|+y5hPh<}FnT*mhA
zh)IN-k>}4){`b69_<o)DG|K-oe7`GS<$*u#we+R@Pe;l>(tkHo{9qP#q%YrOJZs<0
zNl{=GZ{Y_e71a8)KGG2DKlBs0%lr|ZD=|GsU;NEics?b2WUMZjd}judmg8R;wTCHL
zV(}qm4{KmQ!<15f`l^5VIqH{Oqy$o;@LZq>;~;w$RES^v6MG_Z<|ZC^#?CW_u*~$t
zb9$m2ncDMrrlTE4nBtu&rHxFYdc4sW+ll9nJl~)np3U&Qve@Jx&Nv?C86ESZ9Z^X^
zg!PmX$uz5!g(D%Em5@AGO8G|bv|&1)H8NLvrG5Q3j<$75Ir9-N<HqpPW~H&?JJAF!
z#EPY1-MF#FJi{tQS;@9+VGgtkEdwaS2hTT(Obc+_Cg%`r(L#)b*#6{(?OXsmo}I9s
zJTsw+F==LU5YB`lBJ@}ajOXyI4_ld|8J3;r)Z8yE&iu#-?P;6soZn;`ypcVo7G7Bs
zdgLebW%>D?qiN1C5p9O=Jm=%y7O>#xpVq9WoI$ZH&9SclI7>=9j?Q_GMAc9$oH1Zs
zTL5P}lpqCbSl^AU+ydivwr?>$Tf!UjZVungkZTisBgQ?nDl#KH&Nr||JbP!$vSvIJ
zXRm09Pu8Oe{+gM+(wmwX-#$|CJb_vvpB{d(3_NdR+J<aYCEHJYvK^@oi6;_oM4MEs
zL_h8o8?ho1rpH%o+|T#WP9hAg<Qr4-8~<n*+Tu$CHtD?*&8T{oh5IB1QT6P5Y%jj3
zT_Tb{ZD~z}$|EZEr2d$S+T<RIQWC?&x3nAc<u~rD??&DvKdL~=Lgt&AU(z$^leH-X
z_k7W+#3+Z_p)Iw?Ue5j}^JpwFYt5d;+HzKmJ%-As-q}jjJKKSEqf#Yz{H(`D&9Yy~
z%o`QUUMISx#$^tUy{*(Jy9oL49GUsD#4Ih#$o6APu)l=g*h^UJFdk9)>{rY|=B(IL
zSSRL6ue7iK=Ei@{L9t&kI+o)lQPTRAURG)_?$tO;FFLSV5N(hTs$Jqg>mi%Of0=0y
zEdwaS2j|T=+tUiAXpJ^#hc+n3i?OgAzZsj@&Mjf*V^6thLCzVqK)SZbf%BX^|Cjhr
zt0q7s{#PJfbNmY9e;asZ9IHTnoZ)MU-<&;@_}>z#>btdpuOgJ1aZz*{#(zfAF#fl}
zY(yCUJK%c}&ax{|BgX#@D6ho-a+HQ%O5u+&xD0qZQ!{=teS4r~_$xupTj13Svmcyk
zY>z#a_+9_@?}&EmjCLr153X9UZJL|>efVZso5Oz-vxim{I8R{SJY(jvnvMURVOasJ
z3(h<`nzFXXXAAslgFGtWqYK{IQ#&G;GQ%hPF5`b&<WmW&F7<7G*t18n-fTnmM)pC*
zLVjm-p?ZkRQ7DZ6M5z?+6@=_@uZ(@@Lp)3DmEO)==#}%85`UQkeKT+Rsqe;8Q^WjZ
zG~;oW3XoXGD8sP;%OFwG$FHW?$D=gkmPB7#6Os7O)GR-v3gfVhFc{ldP8oY})FSI*
zw2@drF6z6rMry`Ojy_m&vdK1~iVC35QoQK53@`StF#faOSKv=(Y}sR5Lh0<Etx*@Y
z0^<!;BK@-*w(R4q8Dj<K8`*#VukpVlJowOg82>Bbw-dD32_<NO{bBs?gt9Z1v_Vf`
zl%l3NN8JwPVt;1KHbn{BLES800lrcD9;_H0+G8K%e@9bt#{Y8IaMr)V<XwQ?#1swL
zcpZ*jD`*X$HvYFk&UR~quUx0}P&OVLxUnCHo5X)v{|xuF3%(SigoP+`CzQA=@@RuU
z55KuF{<CfByXpAf2Q51QZ6NW#8lOEer`QuYl;Ay#|J}h?Us&}(OEUg<N6wY7EjBFn
z#XHqhg%VYwj6H$x0uP+o?1*$!YESI%h1O?&6936=DfZVt{_l!8CyD=k;gS6}jQ@S`
zOUM7-D0emT9SSW};e8-haa$nbN&N4GZ{<MgC5-?5fVackelb=T2IJKk>&#s+x8D!B
zw8ihXu-*;z8i4)PsO=!5!ul~F@qYl)569dw+rI+-cS9@r-X7ivl(jkXmiSLA#{Xd`
z*C?zrbVfZS{&z!(M!|9@$}}4K*aI3Hj<g+7`c5caPasWzF#h+(UR?Hoz1>hV4|V8^
zR9wAiSp4UC5PKg-kBlNbLQ4GSh>B6E74Yypit&)~mXV$jm7{?|ycom6_|J1Kj!KK*
ziCA%9#c0Nn2#>#9DWT@eU`gMM|MXSgP2xY}563eS|Cvu4#0|#2*7(jNFym|mO41T~
zk@(*MHE9Zca5Py0oQTB#wn!O`|Lm)bQ!FP(8725#ZandfrX3K85e<$1Ty5g<zdd|6
z!#BqNZur#$dhG#r8UL$LLaMzB_P0guy<t;<zS#td>I|Imzc(z|TRS0jThx~EzY?k|
z0>(beNYEJ`IakT}-yH}w#MO%?#&3Pwe+0by(0dQ$-2*<t_`f@9!}#AD<@KQ7-H}5-
z>}vxh_rr_ve;`t{L+`Nhe^($Qpn1msp-3<Be<(`H7Vd@G>G)rTUu*>#|L<W^)VKV+
zNQu{c>b0g3=zkuf0XZFxk`Bx{?S)?+)=RjJLz~Lx#{XU@Z7-C$SAd66y&r1Z2f2+y
z4Q>2q?jG{!gEr!YT=m-|{_kmynFm1whj}Bhj?x0HIt`zU|I=~#RSDk5fhUgtCH{{D
zBJqEJsCp7?8UKeNmh24{%e?)-gO2|rP-4b^@;cpUX%Ob>TjDpz7yE$SQtbb~#Q!6~
zxsLxw;FrYz(P;Jkz%=9kEU+BL|GC}-sB0>?<BBEY|16YH;{SN;I|}#|?`YJlw|5*~
zopIez7wkO>SX*y4UPnT?2O^ptkCmfJ?^x5n>(~ArvEtGh9;&g1H4M4UM=SKhMSzU|
zXPEfEZzTRtM>{S;i=By<I}Bx*1a_KW)vW}382@K@XQ3``{GS74Z^ZxUP|vYg9h;BK
z?@mUliQw&c{QY0zKVu5x8qXlQp>zd!xADINO4SN{m*T~lE}mtUqs9{di8B6oMZ5AW
zqyrSrD=2LI=kbnbW3;LQ!c}D+?PNT`D94z={KZ%OTA!CCR^qP%KEwFm6HHe_G5zpj
z{I5pt{Y<Q54R(R8#Q(w2b9eN+PUxpquxJUMx*$a%YS0Gdk}FDN{67GD82@?J))zge
z3O%?S_8cQ|?Oo!3C6M}VGX4+a|2Sxf@qaLK+ZSH<gFf~{d4@p|RZ!C;lztNSw?!{M
z05%m^Jsb=L?G1bcN^}4$8UOb}`PrlQK)ENN1$G5ifr!u%QEhK{><Xj+(WW~PMz?kt
zO)w5~JXpVN1p1usorIb*{*Q-#xsEmi8khKgG<uc?rS6V$gz^6vsChpqc_8$^KeR0I
ze<aj=Jajz*3ZDqA4@FHG|EJ*FSlCGXKhPYxCc%3-T7>a`D%8X?wT8w2njro!SJh_x
zuStmivtcLk|6-Itw&U<o6MX0R|74W57h3z|U|$&jPeVKR@m9pf|1*J{-+=hP01VH^
zYT-QZ81G)JLOy8X|M6JQyc4bVV{kGZYl@8j*Mg@7DDyeq;a)9PY9;>90s~?EKNad>
z{GS7lw_`ncF*Fm7|3@G`orZL~Ba+?)zI&m44nlsrBZe~m&&A(ec-42a<Nti|{|c0U
zrHTLNgZUevo)@4g#{WA|zh&M<sM|)A|3sAgJSedQYp`pvuK&DuigyJ{eTBCi`s#wc
z691ou+K=>p?mcSa|L;(@hQ<F!(O>UCAFIQ)1C0NhyxY7_pwDxH`2Qq&)&*$I<>n}{
z30y5gS^thz_E(|*-+7M%eFNMx{@;x{G5$Y@Rp9$j;-8xF|61>D^nnfDui*P(l=2ni
z!ubCN`pIuh{J+eM|IhQTsc-Yce&_f<9&v#em~%{G<Nt2hw<~(#P{fKcK#I|yiSnAE
zuFzV4l%WH9FJsfLi0b{Ikur0B#rRJv#_HYC@5xP5e2#*?y1~;(U=siBNGoea=(7f~
zvI->_Z^jQ{{68E~a5&=r4CH<|J`Y50HvSI>D;=@#C=>q=Kxy}c?x!KeZiqX3p}$Nq
zQHAk;G?;6Hei6q1nTWHqp}jdK{_mHI|22qw_1#*dY%NT*?2IUB<Nt9`z&!6plttqI
zC9qimemmgBIK9%l1@+PKe+7EqE$G2#LK}Nw1ag^*|L3A_9OvBxB#i&O-a+F3c_^~P
z|9Q|-eYY_FUxoP61G?Ra>t|--{m+O!9RL5p#Q)!Wzx39j&o)Ot9qPS?*JIxOh)azB
zZ=*gu>aK;F-}JUXL9e6Njz%xi@&979^)<LI;z0D4(}DaL{k00$NL-74!T5hVqR(x}
zvA$akdeAFKRN*t_YLomq^s{%oC(QLj9RELV_VVpFDDi4@9XZBJei;A11`@{qpX2-Y
zsI89wzhF{qzW)o{iqX#J`2T)zcRPH0CU+04J>s?U>p%Xl^xJqH{K@`2ueHzkKgZ|z
zU*i84Xr<SK_`d_!*GT;D=QqU_HxvBV(L0~@N`1!vZ@e!MSx&`uEPcJNq3aI*OrP=p
z8T8E8%!p!yw~K!ou51b8|C?Y~;(rVOcen|s+%Na<!n>(xJ>D3>JD4Ntp@{8s&>suH
za9sT1HBBd*(ZFI8e<nlC(fG3jBkB>*+fu}zeNFtCo*IA7K@GYgmM;DO6n}0-yU#<M
z?+tCX!EuH0=d^_Qa}BP0I|n*H3YxwM@r3c`NfUprHu2{{91A$AS%~BMjoziu_Z=qw
zEJe?^@n<2*F7am}djHx6#Gi+}f8$8g%IEyU5#aQ79K|-^$W-V{{Q1cH4AEwo*T-K3
z1q}B)c*A|hpT7Pr-mmc|<IfK<Vq*Lm=ZEp9%$NA{E5yl--nr=gh5lGy;?HL|UR(n8
zZ!zP~uKpTmZ!_|o=ef76<rmTfM70jkX{~oC`s^I<eWRb-pq0DO$L>NDy%fjMtI=v-
z<66Hjpr41J>kUAjL)#L)A1!+`j>GqOOAw15Hu|{_5uhJNP_IHiygEy)Zt<@7eyfgO
z=O7Z?YV>ml3M#(xmpEz>9>4yKs3H2<+yB^O?|c+D((SCDzoCpT;%w|1Z@NFqr+!BJ
z)X%3V*9HDG^yI72iUqhPY@z=W+M=J|-Jk7S{fzWidTo3jzdXMi_!#Lo^V@lUgk812
z7D%*o`F}BiB$AaO`6b^4v-|CD?hE%bkI=);`O%8A0O6lpXF&S`^Wr<x^E0#&G(<w2
zUUuF%<3~%bVuas04-u}#7Xp)O7$iq}U_RWqZpyT@;U3z#Tanoz2<>Ra)u<AD<C>Vv
zaBvn*t~D?wX1|n(*C?=DQn#Jg$LNQvh*ATo30LsAh2@m*%rC5i;IfA(Hz}Qbx9{Qg
z8N4E;6dpL|E3-VD>*T5#ulJG?hAVqqO=EqS8xgK~b9R|4TRU&`!|QN(y*lTNrBykf
z%Q+=sh3ovxhcm{qiY`}~NljZAggHrT=sdV)$3LzM^H0_{>4VohaQ#bWv^gh0Ozr^U
zj5KZOk869aP!7)ew$!f8ci~-BAnfy<El*~JQ)yXYgM7+$C(^Q3L1ch_qMLXM`Ipua
z57NHOfePU-YsHqAc47*-%7a|(ym1ATtT1i38p`V}gjZ23SzuZz9sP(WwjtB9<+vwK
z|FRy&^#iV-(wf(XkZo80Tt%f7|JV||rl2`qqJNfw>k971Yveg6#XAS75q@%Yf_tf1
zesZJAxRNU6Ax?yQ!fj{YM5r9Tw=?;dBTcA(p4IcN8MZW6Iyk#3E8EmRS0}lG%QcBs
zW<OV@INozNuIpO;b9RlXME}f{x~Bd)m(LZ_HYg2kBoEHmbTkO(y5jUtd(O~t4TPz9
zr9v@MQ2(6o;@ThEqJzP@;GN&Oej@tk+FvW!Q2#q$U%(coC$9a7Dp+DsEw5_h-cbK+
zr%?aGGJ7mJ3nSys<)<e`4qj`(KFE~;>W-gG%hh*A4T*sCN-NPnqXkol{y8JNv;PX<
zR1ZtW?<@^h$jK|U#dt#<vTj`C!b26zFRs(D98Ak~Gv*qnf39ZJ3)!#4i+8Vf!e0sY
zbM?L)X~{72t~6Hd;FbF4H7_0UY7MlF$%EIxxSOa#^xp;JGU~r8Jc$0ejxDPbyiZ8<
zPYs4^&Z2)&WeZsByixyL_Zom2R$*kz8RAmxX>aPnIeA{k!h2P?*2BATxkAMm_e!)=
zCB|W$;DPhQRSEj<g&6>={{c8R;u<aW&($HSiL;~B|E?IPhx%t8v>XKgyBVYkW!#zH
zzNi)TKL+i{x!_{FhQrSgv{3=hGJBwmgHUbGbo4ZPip}>nm>(#{SsdpWL;d%Hy}MBt
za-AkMNiDF%)FhQB`ezj5IxkmAsYYID!mE&|%T}-p_0O4hcjH}|T>qmw8R4kVGJJ0b
zTWU!3Uk?9_Mw}7gRZhGvO0G6w3M!0iuzn1~eZWm?<Unoqfi1`Oo#B`3qSQa50`*Vj
zwm@reEswu=*IgkjcY%EuSW^F7QFS-2VDpNJQk?Tw;>8uU-SJm~{S}xMDhF%T_~Tsq
zaAQUNcZ2^yIP0MPd3}KBpX=uCRt8_vgNJ$(P!{TcVxa#)I4cSDKL|dC;n!f;Tm26M
z!(PxT@%kT(wrG!3hoNp<gPMx=;>vt`<l^Cc%g5Q;zL@_UgLBxKIJ+ppC$%{f`}aVN
z4>bCpf_?G&AC9x$Bj6<*{|vx-)r>&@hoYT*%#KxIW@{YUcrHpI`kw@wQ2z%Q{T~La
zImq4Jj>oydc>M7Wx&6`36Y*LM%ac(~(f`4iF&zu;55ivVDaK3@<NsjTQvZjbeOuwo
zv>Ec>S^tbY)IZPSJEC-zCSFnhyo#+o_O^yfsDECy)&lQTXlF1?{kMgGUPr??#bYz|
z72TMsEqbXBolyVXjV`VJJ0Yj;n6)TH&V6Ac`tJoR(SHx%yplxpPc25bK3F}W{wLu4
zX*%@DyAbz=MnwO8(Q>@fVmJKm3*JTlyTP^!Y8qhlKh`ka&*;Bj)H!|~2%V1vZ>2cf
zoB{tM;bjs2N-&R0{nx<DEd0$!IZs9@7J{YmXq`iGHarZe55SyG5tLU7m7N%)|HCkI
zEc!nOsgFdCEio&`_<taJ5Z5t|Gi5ppXM8`xH_`twW?xh6vHCwa=m!SMy<GzC7a9E@
zjx%=Z|IDBU6H)4WFnf8E(f`$$N$33c(fC|~)~5cigwhVg%tb5gr~Xfg$-&kC)tIke
zpVR+&;C&5J-h~-8>i<b-<wwxXB-n)d|1EO721pgo*>~3eduYK&@W+{o=b-&ZaSp#2
z=g=o(4&X<aQNI!A`zK;v?^f^k*js=-#onJ#@}D5jiKyGPn4h~4HFy>?m+!>rpAoGI
zI35e7kAhN0g5zE&e^c0wGWs8iz9;(U6-%R_CF*}X+O!ZY$$KrS|7!dVKpotT`kw^-
z4@H!q{ttvI%Ain*|Kp&HQP?*N`PSt0zYj_<3^QTvkk?G$hZ+5kLB8?&KL+zw6R<)t
z9W}iI^Tt<u7YF)Zik29Nxs~NmVPDKsEkg0mfY;0MZ5d`48UHUs`7S|?n?b|pxWz}=
zZbaEO8U1fG`o9xtssGpE^=7007qIHVwC|x5TQJ)?9=Se`If-H3Q-S^;L;6R+)44nO
z{{(YaH(=%$;~jqj=66K@*Wr`;=RB^}e=|SS|5upBT@8+!`PBdIX5ROs7<GEy9{v+3
zE#trF|G$_8`^c;E7eO7R{yoTbn*SZ<KdJxO{=cFBss0koA{F@Gpcd6W_5TF)|FY5l
z)5tBl@u(H*=Nu?=snO3uq!^7BITWfA{nQ};Q=r;VKNlGNEXnC-uF=oYQRnz|j?vFD
ztR!u~w-Yh@brt4$?=bqAhxLL`Ki7kal~CXrm~Z?gm>z~%uXd=_uaM&-fqsrj(2tLY
zWlit~`qRDc{vgczU5y8DJ&aa;(5v(Z`_xZQKh)2fKtHYgWnO201N5^i+Ov-@`soOU
zqT55c_PGu-m5aUYXpcKF+cgC%2yCD0a_zGP?ehitH~ZJmF^4=D`eOUs2zIabwjz$)
zi}_7=8|7mT0A*qOyn=f<AM$3R%y)QiVdaAD)68f8s`O|1rGAb7IZEH%pNAQ@e|m@b
zZ+Qp#rvpFRFG6e?gO>Zubszc7%E?R4pygd=3+#6$;jf*VBI3*b;5iVj3(T(YS9rEg
zUqrZHFq+98lOWGqID^A^1a3umg>zPB2lh)z`OY&LDNDFlY?9x3e#O#o_J_V%UVdkK
zA~HwD-!gkeD}LiBJIls1LT(%%vxGcCNbB-Ul;@vfL7()<JXuqoM`qc0hAA!2)SRv0
z>`AfN8<vo5$T<PoSQn1xr9JcI!SOw>mgiOHysAcK(&RjYe)!^6XvPMt8LxKd_+RRs
z-#@RN=NSvn4`hao=Omm_k~ufF3D0UcJHrz2UJ%argtg0`L#Rb6k+tUe7{7;Yz~8b*
z&V*<cV)?vN7c#FPzNvAlkfoNKL@zS)5zc{;v5=4S9O#X6gM2X!&+(`Y&N*<Cw&AC=
z9+_s{*kV~W@)qi!^H!W)qW-CnQ2#u0B>Oz4=ZqywPM))DO)$EU^HQ1Tr2aW~AqwQY
z6)j|Lj5XpJrQGc!y2_UaXU1e!l=C9IFNjxNQUAQom(La=`@BObZ12|a&)Q_ue;LM5
zY|++8(-GtJw)jORIQ}Wb(UDi-a<lrcL<u?~Po4|r-&$k*CHn7VTAZo7BCk;Y^ujA6
z%i)vyZx5Vz3Wet^`Ern%S++V`MS3M!=G+?Rw7Bs%HANk;RcOVymt|vLWNS;`V%t!$
za(67}(`D|9Gi98Oq{67K?D}tkc5aF~i~c$Dz*$`0`NFvh&dNw^5dHIBF5Y3rbLnjQ
zWc%|z7haLs5uT}ka$E_|ykmt=g6d%O-wFBg8?VG`1yts+^0iS%jGd`}o+ontL-gMT
z=OYsTL;drLLEg1djojN|T+6$yvTU3g>uFM!;XJe-O4b)`&>1a5{dY$z@VZJ~O+)=N
zhd!uLHA<DO{QZzd^v|oe+hR;B`schvSB!ni@#1`9RR6o7O*yNTe`}4=IrZNMKDwbM
zTK|1fPR^P1#JL2|C3{Eo&oiI=n?yHWk<V2cSpi_17o+?>T8JCx!l-{n9L|-|s($+C
zv#J;mI8PMnpV$AlgJ(WfjEd)Td8mKhb;E1^!+2zhkoZRZcSX%P>&ceT`schH?|Es5
zPu{V|xeY!CiBF%ZkN&HW2e0xUfzna`Lr`8mi>d<Wi=zL2C;_i<-VF*HgpqA4pxN|e
z^*<0LY-2|7oUQ3%G|Bs482@{LY0>{Alw*|9|AfRg(Lf>2j6(hIkJ63C`ScK^-#yU(
z9?<V3jG+5Kryj0|5dBZXd0n>hhx(t4bKLz=wquR{hvTfS6}*P}KLG0F@zF;cPQz^6
zd@!6%|NG+{VXvJ2=NSDT4i7~*b2uKYvIuAPbBzAaK;AW|O&ip326D-!|1KyAkE+x^
zb;6?+uX*P2%f~lv-OL^y;TSth!8G+Rb7ICI<&E*bE9xrx?~l}6)!`M&y#9G0^xqfX
zs<3x3UZMW^e7CMCUM)oZPX=3);n~CN&lp66!B9<8FgzCDr-JQ0@oDux4f8>~YHBy@
zB;{Lc%urDOv(cg>aOOWA`7A)&SAyXRFhKoJ$C*`c*irw-psw@5&j7HWWuyLS*$Hi-
z^?y9h7W<%Wer)uAGV+{_b9WC~rT&jYo)faTN9i7f561QR&}ToKUEgQ)e+6bt%5a9d
z2NZOZqyHmN*8^~6P?qhdnBQakzdz9bOZc@I9)FMPL=VIjYUOw>!&ND_g3$%A6aBvm
zuCwd^G0dy<LCLSf4A^SSe7%PDJr_RTgZ@9p+}IrC{!5(sQvX-fTmL=ag-69*q51x3
zk7}sBPfq{U_)XRsA9zhYp9VM@oa~ZOKh*#Js4Hh~cLRqbjsAIsl-2*?M*nl5(lN-t
z4f^|jXs!LTG(YS@{m(+LpNcDimc{6QnbH43sI?N@UI+ajo3Z@V{}qA$e*rB$h#8;-
zxHfntt}WvA%GCdpVB}gn>52M(4RaFn!A(~E-;EiZ4^Y#4Ft6rgPUbOuzY(6k@&1Q-
zo%LRG|2nif_5YdoC9p}DU3n4LO4V2Y>rkryVfJn>|44r;;{O%6&an(v6@3!upI0!i
zL(8uN)6M<t`acpaSq(O=e&z=HIRG<o-GEhNu1EB9B5E=fHKBe^$k_f(VYxp_OZ{Ap
z)}emR1t$++7QGGTIZs8-hocW33l@f9UTF`^=iOdU{rnB({~P-63_N3afZxM^72Mt(
ziJ#QZZJ7K2H5i$OImh9cKg<?C-$TjPV6KYo^E1=G<{}o{h5q#i(>`m0_PGl+{7kja
z-;h_9Eo`5!&^`zGk753;z#Hqg@!3AFd;9yR;=1?4aot}J{{nxQcZAROIo4<YYUyY3
z&lwAunUQZy6YdGq^9U;Q1)MXGU!k?k8*m@bojCi%832BhP39JO7AErpGDjuPArK3C
z;#g4Tu4u(M4w*6H84k~e`69yAR9bUBU&fDIsplR1;S&fr3gH<UM{?X)GPys6V*u7n
z${K!#^{03G;(q2X-^24ksXxyk<vdSj*<c1cj%~v^E|!itv%Ip&bqYN9lP4vG_2+d?
z+?XP)Kd(b^>(4vZ`J4>apR2;GD_5I&ZpMw}<a#sj733YL9M!S@JX7b!bAR5`&nJ|~
z`Y`Lraer&V##UHkyYozh^JAQC<e6Gnf6mhJynu65oMYqpuGE>=!f;lK_2gM9X9`&V
zaP-8x!}yF@*1r-6pZ3h_9Blo$V#rY$pBl^h%k>u=F>vEJyFXHOLu!t?yJ0-h8^@Ed
z{=Bkb2=;{aXRnRce;^{!9yn%5{j0ocSPaB#FkUQ&TooYg&Z{0;p|qSGvGwQKG4H_R
zYO0TREyOoIXM~&7pXZy+PztGkXYB1`P_DKQ$1kp|vi?2cog;l-VbR@K3`E&@PaL0{
zzBj)0#^|SsNv-QY8gaD}7Kfq!2Ov7`m#hDQh-$~<xXb!a1Q+w+X%t$ZCdWVPe@3qU
zvyuN;)PF4QA>wB1&nKL;N6A{@=)otQa7-oq+xibi{dYxu21V*W93>xyzXK5C`hkDm
zkIAteH`ad)>VGKeKLhpO$JGB|*d1>0GlTlq;JAJ%>c0qUVAGxYFT>b~^}h;7=d&>q
znu#O8NrC<!MZ`WH$L30m0$Kl8as0UrW6PRgt*QWZz1P(LVyp-Gh?&=8MD+{2Z2fmd
zY4~Iq-T}<|k3s9~maG2|>=FL=K`Rb5_pA=Wm|OTi2zg$FBiAsL{}z;;^*;&qKO5r+
zZg)EM|1Ijj3}-Mm;3&_n*xv)IRUJ^?HhyQU+Wdg~2w4Bsf&Tvl{V&5&{l8eF+smKh
z_wj#;W7AC7ZZzq6Rl&)~buU~$FyEB_0JOxpsBy?2%RdjlOVM&H|L;(@E3oo+hDp!z
z_wrf(9{xC7tNbEXsG9o&a0f!APlH$B{|oqk8vZ}QxTgzP{xPnV4*fra-lzS4W&9uD
zhyKIk1S4qposR7<Q;ftniO4o3f184t6!u$^139WNo^ig3@r5sm@r=d!Hkm)PbLEUK
zOwAa{xS4O`SsRZ);W3R-pEH15r3jBfv`E@`J}Hrw?~J;<(vR17FcJ%rl$QIM7iV^O
zwH2c`S2OsW9bVm=t^Ul9*1QHx;<&7C@LJvcbJTKF71r4Pa(rcbW?Nxk%J8~H;ZK-k
zWU`|S7$t1dQgS?#V>S8b(Tqol@F<;-7`wUp!1iWod1U9z0LLS23%TksIV}<4pYv-n
zreSJcT`K(NpQF|M%N1lie)8zfE7I!2e;HyVuTA4QlJMU$7z3o$fLF9}e9-~%Ncd-b
z=a_^1=buAji&29dJ8`W@#usvhdX^b>US%r$%awav2_hF9rQrI3w4xg<<ey_B{%;d`
zavf(OIqR99e~xK{e?A9^V-v1Mv_>29$x9Mr(+W{)MmwA>=herZke1g=aU{h4pMMUB
z_ovW`_w6@FYR+y8{~ZvO^QULqb9BP{L5HE`hTwQe{(D22eKPUS=RFAjoXM(2n$CD1
zj#qv7m*?P-Nsg~tAuXRsAiX24{dnx<Rl1B^e8x&!d~#-={AJ^x&p#+anqGL7pwxV>
zOJ|e5Cp_fa_!JV(hWKc=b~t)A0eia{{zt$oXXn$mDF5RywipNxV-5ekFk;EKRbfV8
z3XJv&_&*rAj`Mh>CHW_kzJ>gcG5n7J|HlOUkHr;DlhYFe<u!T2|DhOXoq*9#Ym7pV
z1ph~(JrBv7o==D3)tX&k&9zFN%aH%B_+uo>w{fiB8mjlvYGvSocR+{ycgMLvzHKP-
zA^#%`|AR2j+86ED8Dr@^Fs2-uFF8iKA^#`9&qB;}91i}cpya2(>xp^O&w$c+zSR+T
zip|D#UBdrGXca!6AV2?SVXkos<}Pl;b$`cUHsn6E`?VOuo(%pkG}m3F7a`>T4qRcw
zYtn{b+$sJ4PVj$!dSalPFjFG@{{j5JZ}@)|_X!LCujEa?2ck@SGcFxy_#d9*pCjn}
z{2z+(=EQ*i@!<bRoZakc`akcIpP4uR3l0AV<L*fI|MS8Bbr}7ggjv>0GVy;4_&*!@
zo`x%uEdP&Ue()5mT)dk%{~0(}S&bQ?yA}Tr;f&!r!~bh})A#m;|NZ=3e9eCsA6KUN
z2m1LO?18faY5!BqRf|hh`yT{d<=YO$Oq{g;g{Z}fp#4vUs<X9!cmHv;+c&sskL_RO
z*P-Tv{N_H}|8vZy=Gz`I<>z^al>ZyB$M|tGRPY9_F3h*J_ZQ*6z||psOvKrfl>dL;
zV4vmxAVEL&Y-8u<<>*m1o<-PSwj3PQhzB0w-7^dx0lAOY@6dzH0@>8^O|ELO*DP6_
zV-b4gIEt^ZG@%9OgX9_{&ew3ZD7vvmypK+v7Z-m74rjtx3)esAs>1oPxcUn!clvN`
zVCVXC+|2Q}oJ%CvpVv0DiWVNfI3APw^MCg2Tz}q~#rkvYnPaV;>(BYHmN)`%wK%T+
zEFH&};cQ>D2y*QON1vR7<XKg8;~0hGWZtjE`nxsYb?|)NqST*HeT;5ATJVgAqixn-
zep{QqX8c0_rT%UNW&L?o@UG@uzh_MSIgS~CD9ZYG$2id4Z2dVO>5j1F>AD<!vHlea
z_3wuIS0VBi?{tLjj^jZQj=Q|;r~swx?qt6^e)Ib6PB`+i{`{@CgAujc<0v)+_2*jX
zBn{&Gq@ezDakM-E^Gz=Qd*T@04l#xG$Mv#1)xR92<J14hKhKY37S3kEC-QJ4-^Z)Q
zU&T&1p93`vV+`Ik!us!LlbUbcv6@$eG8_pHqfvjE1+zx1FXwZPHT6Gqr~2P#>c29m
z|4(+R|9z<ca;%$#^<QFLn{N*z@5{ZvV3y~nIJV!gQ~ieo_3sT927;%Z>wgeNjZ*&^
zIHI`qy9CFGWvKs3%;cSd@!^e5{!;%fxE@>T|DuDl{@>^7|M5=sKhh`vBeBLs{zu~~
z@94JJl>Z>ic=ba5r(w($-Oj+e%P)fRuS5CoiNd%Nn&tll&sSK46_jsxD!=%D1OD%X
z|F3rPzndTW-|8*)clPgO7yM+TmA~-V!8pxV_&fY2`>nO?7uygE(^!vTYC%HZ?x%R6
zt=+5-e&g(oe9}UWfHpVALgIY4d*!!{lRT#Ij~1b|9B0JFmdbt$OU6CXjmIjPN8s@^
zJaX{}A^9>TXN))lB>ri~7dP6_Qf89)DRWfed?7uvjQlODB2p%LkhD?{Nfnlop2Ll^
zZ*t`!ebJA+Bwsl`@|Y?9Z3$Tyj@@~r30sMCUYvcDjb-2(1z&RYpVW&sJpS?uNA96T
zI8(_oM>o!4aW;w@)A5)VjxM;DvtFzh_sMvJZ5N)mhgaV+HA^biEFq5$jHL9+U*V{M
z9+_HHV2^%MvYpFETV6*=4|2yb{f0g{JIA^)AGQ+zxc0|9*miPNCsT0Lz;+O(!<j$M
zhO%CqrQ)%UEyfumX=#>*FKGdMF~9h!H?GXFm3gf#x!~A_DY%E8crB|OMdivtuKCf9
z*TAuMas{=_6v})c?^0!HWpv2WNxQHfau+nU#1<9x@$SXsO<Iq$zrr<r$to9X%$DWT
zAvw>;dmveM&bhGkY*CJ7SYEjTTll0$){7QwYu12Q6w7FgD|@UjTVKXUY;CE5yaUW_
z5(~&1{YXTh6>G>B-$g4d4Q<E*_wi364cj4naj(Pyv9rBL`l#e${fobl*`3Qr<#Vs}
z0P#i^n2!7q3oXb9_t1)aX(u(~Tr<;zb>wd<QIx|dz!cIOBscLYYL)uJz~shHyU`<6
zL?2Y1^gvlx4wcJwZ_b`_?o#riX1TGq$b2fxDm_@{TiJi;Tl!TP|F~C}6-LDm)gdh>
z?=Z=297FPs2y(*6Le+3Rl;7E>S!(%j8PXmsGj+xCa=wmh_smPqd)U65kD(6P^IPJR
zI^+MA;Hm`MQ8-{N_$+PqsI>UUF<yH7<MsRO!xI14i{yXnGEV6D$NOn*{Nr=4`TTCV
zvR}u)7RZq;&sv6YC}ei$_G9l1;~(3DJ+%z!7%%wjf-wF`Z)H2k9m-^iSK#vgb%}p`
z3b)+zPPMQHvkkeAs}r<rhhKauIPXP~b#1PM3nNMVa%MUj|9Jhj#6SKgUx|Nmj{xr)
z=Ef_kCI0a@%PaM18O#Uqj(@Ud<DZ;Gv3!hOyc>XZ;JFT4u9YbzzQ%0wtn*T&>;&fc
zoN~6BjemURLnqXlS0{G{%KsR`rzn(RFCz~BJ8LC=OZ;n({XDMn>Ubh@tpl&n;8SC5
z{Nq!ysVY7_!ZUN$N$nTLKe=Lsv5OIey+U4mmm@h9Ej?1=jKm&ln=35gi#=L;E~66l
z$Poxzll_AInEu2!d$&Y%iD01$bu+RYOfP-c#y>JdZ4#q5T2NKt(N}n<M;;*<cc@~n
z*>H@(vtagj&QVCb;jvwge&S2|EZ5oSL!wPw`NCBMo-5k;Cow~=ap6^`^7IBiSDVjb
z;97qe|JZ}1ENmmLO2`vIc&7p*5RYr*gZZ$$R33X4OT_<u!T!PPagzA$421EISHZKF
zN&MrT7Q9woo&&>(!2cV<>*9H54QCI+_(x@N<%3uLw1Q0q6w3Z3cZKl(74v_1u#D6z
zJ+QU;Wbq0plK-KD<z)+SlXvqqc;h_>R1dGp=hZDT{$md<GHDqHxPHXw$2%#y;ysLi
zospB&T;{krzfbm9i)j4gx);?ZPq7H&AD@s<9WixM`KoY^PUTd=mL=_p9CyKYK7+hB
z>e&tD;u-_j)O^e~@F^&LkyjOLCI0cbr@Xg<GY|4?em;MPPuk!!jk#|Z)T%F1^QslD
z33W4y;PaHb8-D3MseFuPe2NdpOS>RX_V#wL=Vs&IQ1hEJFWh*40b7ax6+_}5uS4g0
z+%SB4SYPOgcRuZhagi<1m%CxD<6k#i7Zt|8-Ug3*E5ms($9RJ=BN4{Gf#!;;eyAt^
z^LHr_T<_skV@{+5vlqNxhv)tyu_ugwy<kNzjDKW7;$J^_-36uVjynH8_TB@|uB$xs
zJ$q)P8I3g3sCQ{pN4<AhmaJw;wk%8TRkAJFmXRe{as^|?2A6;_CI*ZRHpLhl;z|kF
zU~1@boInUB5C{n^Kne*rc{ewCdH?_V&Yp9oo->B`-u?Y<*33S;t@5???X|x3t+i$$
zCDTdaDlo2lJ)gUJ@)BZJFYJ+i&T&-2m09azd=s4)7wd_uThtxyEM*<kKR@)JEem(&
zF`oK5bfBX{jxbqUL;vaL?^ihHWxC^qbNI|(eWNFw^EHi=OJTY!{y3vbYpG`~a()xk
z0m|(Na<B#Bx>KxR3a;XjTNRy6;Hals$F*;iV(W3}KkGv?Ip{SPUovN`xH6Z1Mb<~h
ztKD@-A1zZE;x}Cuf2P1W*B#3B-)Q)t%($~g0q&S)CfDv2<1Q7U|FpdsoB^b~yYt3~
z^c{4Z)Hse+tN-+ubNp-ycVj3?nER(1;~F$t!L-*oo6FD@zLnIiR#G=35$=IAle@`C
z*);51CH*%aJm>S)^%sP-nGz;r1)54-nF)k*dFtN4^N~39pMG=$$RXE%vnXX8sm;M%
zS=>=(I8x~9K?QPgeukkde4EH?4)IrzR{iJ7$!fYeNc1`|E7yN(7`L5>)vgBk^&wmj
zg!2-ObN#oPoUGZ?;kWHS?`*qt)PJVVQjMHVF6zJOJ;FB$|Ene7>W(|sJok8*!L>g0
zCH=RQSn9viuxN$;+d-;z<eZUW5?*(w5TlhD3+~sf{##BC>c2C1HiHqySwN!x+r_g}
zpq%^l{I>e<RPu^;KqdWm2Jsw^&h_6p+?Vv<Sy)RAuC!k$YyduMU`hXN1lFE{tCnnm
zX0KwjF4untlm0tE4(>bAz?-?y;X+1OHx~8ZKCGmxc#>hkwEee_SX;2Qj-qT=`BDF!
zg?)J;qv`5DeK5}<Rtxq(_1|&Q?}Hbi{|;k|?n(aqYCC%^^q=!)_0}B$Y!f&}0JC$I
z+?PgsvMWAWYhouIWo&SYr|)dEH$(sFfvWzqwV?jf8Xx;})e=)LiXo&M&vU;#(SDGE
zUF*ki;;9onHzFUlDEt~t;cz`LHH`Yt`Eu$%cXJX(Yn}7j%JrXLV6hVe^`HADmFqvP
z_0vfoyjB0T^1gTdx1Cz(?kTQARZp$Y_1|Jjnw6ka|E(jZ<?ti)-yEb|{ii?6O6t<d
z<WWZ+_5+;1vywY^ftt(RBu0$afoVtmw-Y?qQImGTarNKk9{GEOn0vAEtN$*bK3)tY
z>c0!nNgJTU4xrx5JN4fVN|PIViG30Br2e~-6ej`6NS<s(;@sb4XHoxMj!bTa?>mvT
ziHv2QO%7+1yDLatiKHGOzun|`eg*w^jQmUbZx<9${~g7We<;<p%gDQqr)wCuR{yy-
zjVorW|E|Rft_Ir%ZEI;k9Or5W6gdwrpOt(})qj_QQ!Q^satva30C$zRff{xVxd`8(
z9_e>I*e#)!U7z&d#mubOm-OF*jH}-QH6~L_kKj4{DDa+#hwCPuwn5#{e^-(3W2D{6
ziYq&rr}81B?_owJE&_v%oCn|=yc>A7lje5DO<IXPfVgj=X5Rw!ZvtAs#y9l{pY6Xl
zK%G+i?`E*HcDP#kHT>Fk4*lnfE{0P3?|$xFQ7QD_7mK3}?}GQ;>%S*?{x~BTH*(JP
zpR3K^!+rPRPU!Ul*!?YDyz0MO7@7GIw7Uaej{BKmb|&wB1^+|;Jr7-;Apd>D3H|qC
z(tj@#>xB;b@6M$E9%IJQ17Q1Aa?17JBhd4g=)afY#S_d@DKLladp*+6ujw4*rXLhv
z2zRCe!Rn;{+)rQxl2p%=lKxwpYPEYII6BpUWUD7f5!aT5YthX|<Awg4Qq+G_ptwFi
z%i-oUVm6_d-D_qov{(Q6JTzbYmQ&JQTbiJfXZ`QpV@UmHy_yHr&LZy(z^MK^3CPud
zr$9T`rrQAY>c91={kH--x!RffZ+X&x=O+E<H>a6=hXLClO0w;;3z~%fTSHDwr0NO2
z?Z|5AzdI;t5jA2wUn5%!2au8(T<7}l_D=fmbntL~<gMtxw;&sL<IQvtwcu1dGwSe<
zxe7n;<<yaFj2F&BlFtA~+kgAfG3viJQ>)%nXaT-!d(nSCB;HH-9I5}lk@VmF(EQP)
z|DH+u?*{6L`tKoTe<{beC;j&#w0;0-c$s-r&ob{T^xwCcA*uem4;~L-g(~%*8e$)%
ze1SEqc5qBio>Et`p3o25_20ui((hYHdkyO#eVID(7-OQJCe`=RBhT|ORR4Xi@Lp!)
zh5q|`(tlsa>*q`O^pxwr_XB4~{r7kHX#E8JcQ5*;z-mQ%f%#?dei?r*XJ)DYz6w?Q
zas7*4^xw>EC%Xcu|9*sgg#P<B+}*((fCbrT=CTdSa{V`exdH!zca8e*-;t=lhllFF
znc2TGckDmWf9K)fe_9&ZTn<c=vgepFmSwMHWv4}8`+BHb(titB1N|oG(YyY8HTCx@
z;%z|-A3+0O3SCws#gmzXVEx^XbX}L~@5M-$>wsQ~WFF^;`g<7ty%&jE&xmR(SPtNO
zG8p(bA%mA7bGBbDLAP6fuR}JcfrWF%k06V$L8`33*Y#3=k9Sjl?;_2!$jsg3|8Y1J
z_4iG9(>;LhdQ+;u`<S=+Uif`AHEKP48j9E5tw8u_s=sdsuFLSA8UgO_r<S<)*fHpL
z2w8qps=sgKne7+Hzne(abNyYIZARjTz@>Ut;V;$Se$2r5QsJL~D%vl%qr;yjUR~kq
z)PeU?v%gvxn|&wM--X!+SjX!sW`J6MTe+LVy7J?*sK4{GsK1{~^|uab*oiiupZ&D3
zK5GHK5kSxreE;6g-+xT}{TrzL9Q=Jx2mZc;`uhX;`})M+pCE-l!ME_)<OT5k#NW>*
z{{Cy??>*G2FGAZN;lVYUI{zcE{0w#ce<c3?7jsU2Q}{<<{a^5=5`ULwrxJferhfkS
zqJG{6GS_4+tPD4t88!D(lU;}IluZ7v%TB@j4BJMQ^S3oyk0;&G!r9rajQbzRz6)K?
zg0AxS&*AT-P;pWA&xybDvX7C^KNW^#JF=sc+sc}A^7la26a64>F*p(wE$q0;pZ9*Q
zNonHO^trvb_f(~~ri@f!JFewUyT~gEwsOMO?^Sg{dt{8rX+_n3>{w7xtGXN<%NAbk
z-L+izOV`z<wG|am=i^Ud&(>a3Z4l!a)75GhGjM{c)#i}L3qJtish)n??_<QvF)?${
z9wrT{3)<}*g_R4Af(QMp$KSMC%Ct?zJX<NC<*d5k*tJ&l7^4eozhgMn2RUduXAUR>
zw$-#NR2Q6Y>e#k+cWr(FNA>tC@wVZ#i^~Zyaa{401i9zPQ(yS+IK&9bv{d<TU)x<o
zs|_(4=h{44JzZ7TRp_h7UrT|riwE-E(+}JcpT6+l6@c8ev7G<Cjn{R?OS`Tk5!xVw
z|5`0Ndp&keRl1)<I_F?GKBrAZYiZ0kF2(8X%DFbqb8-D-S6bIrqh02e1o3d?DOdZh
zHaJ&!4%C}S%g3>fX0F_4xY{s+c9x?>we$sY{yQ2{ZCF4be-N#k;Qvf=8BafEMzzUl
zscH{$#dk+oX2MN<VymzJCH_xM_NI*1<pTP7)rLv*!Q}rOpjiJ3_`ia_Tobk)`EQR@
z{%=bCyJ{gQ#jB%-*g_x0)vl`zT2|&TA~caUpKJXz({niC74m->wP*?Te@7qqe<`iH
z4T=9dssHEG!XHncx3kx3&)6)c9W|bIaq$0Q_^;ipdj6k+bz=iG-%Y)lM@!OO3m4E9
zt2SIr4@CZ7MW5o8@xKlJ-%e}$5?ZXm|2O?s{C^Ps(<ZGl1pnVetNStRQg@}<?QiQN
z|F57IZ~f2t|KUFH|LgR1ABX?P=_%bpAN%ug^96pZ4U1{x%m4dQ{lAzV-a2NHSI_@1
z7Ww}*dQ$TL<9+1+4+=jn^8b5q@7>tE)c@MustYR$|7Y{xmU^k@68)E;T>dm-_$=?&
z<Y_#2PEmT6$Br1KTvDPw{Fu`AnECma_b%)yl}gL6%{XFtWt=>vcc#vt`99ArPaWsT
z)%TTyJ)XShWm(=w2_=8TC@10tJaJtPeWbMqWa@w`pp883A(iqr_U|?bi+IGJ`8&Sk
zv+%i#@ut8nuJsr(wsCWO>`VEqFClu3mS>5UX74F{iUNY5N-5{yZ<HN=mOhCdq`l90
zW*&M=nOpn{r@0un+F)uSvqxq>RX--rQDQDX`B~`oW{7g7On79P*50Ks3yV<7<)E?m
z`d<5Ic|NZ;*kjfM%RX%MWc5<Z@${*E0sGj-i#S4?Ly}__DeQe3Gy3rU3boJj62b@0
zr_}{Z6)XE!Vk~d$;Ra0NZy91?sm2!j@N3ii$R|Q;nuzO_Jse|44Y&6ex#+DVHTuHg
zYVi<qeQ{%6m>x!!AN_CNg!jBO_L(?~hj>T*5EuLS`tVlYzmN3|q=YytQTo_PEoI9m
z_MN4seP%5HmMQ+)0;H1A1P?=YwU7i%!WR6t*Xy0Q$p^=Gs|~K;Wh%$P^qCVPOIPv(
z4msjeVH0wB6du5O7~1O%Db;J(vV9hL*b^<)U+HHq)%R|tNMnLT?{%RQGHZhnM6I>Y
z8(xcph%FU_J=YvkRO^Vi1^tE1wNf1Ui(jGlnR711#_MW>xGO1IE@B-sy?|YR%kt!^
zypa3et6u^WVU@qGvn$>7Y?RKmJQ0%6FM3l+L!TK#8-cl151)QjQbj4!+bQa(J_q8d
z=ajY65&wWkh_$GQlOByqtkP$Ra@QcPT2=K34P3Q4#8r4+RbM~cKh2RD^VFBqzHqMp
zgjkP&&^5->ze~8}Q22|f|Dt9}qtJiaA(T(;K&~n$XQYDOTFRjDs}13gtQUGnoPFbF
zat$dA?|D}((Zfw&Pv@2D2WOf6NTsBPx3)Cb#^s#Sn)Iu^D%PCU=A#z1=IfRAyVrk~
zs{H6js<*X%WugD{iwo<M{@UW{yixZ~)3eTf5Y-7@NxR{k_0g*~xE_cy?&^2pKdU#k
zzMp#0O4E@E4&_ejg#NStF@kqW+;FZ+`cL@s73ze=eHiu56>3*Lk39qXqW|=n96?(3
zpO#SfGjlEC(0^Wq{&Pn^tsTRN75=@>u~qkohc&re|Cz@Cpb1}i_b7DDYuDxRY4!c9
zq2wTzV<|cI!n0N?RqiS0p`W|bsOOFrBq{D*hS6ry=f}D-lo+OI0)o-lw?gy9%JJGS
z-6?!5zs@-Dy4s-rb4P>Ff9{p3_mcisx&9jkEHM{C8(}kkJK8Mu_HPDSWkYZ4(0}sM
zJ<#0qNsXyZvp(Is&(nDR#7tXHwL!nbT>rUlp1YoDt#cmnSnl=h*0WH5Y~{`U8l7d~
zj+3rv==zNAv7l^*{tGL0fwXEB*Q^#NadCe)C0N<5Hn>**WXjU=>8jI?r|Kte`D3|v
zA2{`&{?wuW<ZrqDbFR8Ivt0i<19~i22DNhiH<=QQIfmS-4gIm}OaY3}f9}IIi6<>^
zLQ0kN-xy*I=E+nrncPAD3CGBkCf9#bdn%kz|Bc{nJ=Q1n-$>xoN8HsTf7ij4H}wS6
z!*v4KOru;a_v$*=cXV#cbfB04G@<{d@?;9J>w!o8H#5;roijS|q&f)afTOt1CI`K_
z-LupkA=Q7bn(w}n?xZjpswrdAu7MQFkly^J96>61=sXwqqpTw*SGb(bIoE#^fl_}t
z_1{c#s5S^uD<#Z9rt~CqmCR94VkG5E1XexG)qmr7>T2okOW6dJGr>#!Hw_xiB1Szi
z)qm~-Fpy^pkViG$Lh6Jy%9^In@`CiVdi^&S3w5slW&xe;i_m|wkrj`z@N63L=x%Ox
zlsAIA(0_XC$?1~*lMAEBG4{1|wRwFf7XbHYa#8<HBSl~IUkfP~P_CX!a>%tR7h%a8
z0wtya-3-cd)p_^vTui+Q{ii=)3vtzdQ}9o4^{*!4&*yIz_bYg(KWVQ2R`9F|U!d`n
zH3x|MqW_#%phUD{nRE9__21eA^H}cZK(S%uJ_6{Je%EnbNLf?iU9SJ;gO8rj)>Hke
z2N7=)9991<g(uC}TNjY;N`B|VA7>O)8<xV&_2g30e+wvk2`~=_UiIHXvI_mD2b%lV
z%m(VYl<g`SO6n}|bFB)W)N}1Ryh})}{?m)yXLE_U9{JO2dQ~6BC+1)cpTdYjuKzZJ
zx%$twj!uAP`ib|4<74o!S;B9w|J<iH+J9q{-<j*G8h0twS_=eQ!9xAF3Ml8|gQJ&S
z=)bL$@VnQ4tAJt(V-v&hLEj8ErvUE)XsNDqN6lRS?SxwT=J#h5Lj89d_mhCFiK}S;
zts(ZxYT1kD&~j+9m@x_UpB~y{3mf2e=s(x#(&uy@6wdYELZt09o~Zw}lX5okHv&a}
zQuoIrXgji@{##9+v+z4w$KML5xC5`3(0_Zts@kxPoLb5GeCoof<kSenTghn)RM`ov
zXEMH057&0^^dc}<|G5+D*_5yT(?9=Q=&=&{3jMc=vwJI^K#WaT#5aInuK#x6A?DK)
zss#_(H~`PK0!e>7u^ORG=)bi<vpgL;8SOa-&9EIP>ln=m{kM^F_E5?e-noCk7Gj$w
z^q;G5EF(Ad-?_lL7I`=id`}_v7Jk=P4d1!w1ohu$&ixsMQU6`Zc*4nW<btIC@X&!y
z>c4}ORnmXwGV-JTI}ga#GkUXy91id|3!kpT<a0JT?1nq*`E{+5EztN3%2NO7-C13j
zNDa&N-*t>`^doKPzYWMw=)co|AoSlQz<efi5t`srN&g+hS4{mUH%|bIZPfkq!A1Rd
zB<a6v8NX8hUB%li#5r6YaKy^>--S?q91=Jh3@>H;tfc>r5G#Wk7gN?kYQhN0m;;Oh
zp_Tg2S}>F6^WfV7=zcl+@2sN!+XEz_|6WDRT>sq&9jXnX|K5ZI>yv*0e4YfBE%>0S
z|Ma`Q0Xl^Kdv#$S?<U|QcM9WCbC9R=csCXw<6Dv779>>tcP?INZFrT<rk3x9I|qvT
z?-<f)`|lnw_}%NjyU>5v0KqW)J>OQ;f44x(b1CZ~D030o#`fPs@L>_P=xoNbu0;Pm
z%>7|Jz(fD-A@&>b#_gN_do>hzk{sF?-#QEw8}N@j2>)&Yo});%evG02^q0Srn&}Rs
zhm!vLJ?QjKU{U|Qo8t`p4MYFEl{{zR^|+3G4ep_?ydQ7wTY>K&^}a9q@A{<wo=^Jk
zA^7))N&h`c?z#TEg3-Z_`tNDz^8oVLfOqb*tnht5e{Vo0ZU4QqsQ=zgjL?6NL+_iZ
z>BCsf=QHS~NBXS)o&vMO>@lqVy9W6_Odel?R~{c{wDYs*KfRC-;lq40dgRrV^uDy0
z$CJE!jK3#|X&QZ97b9VJlhd(w{r3oXe4d;>O6({3eXQE*fiL2H)L1>NL;s2O%U$%}
zjY<FMx!8>Sj6mX7AbEeD^xxO;K7AVf_wl0sduP&r?}ox}rheRkY<?bmOZxA@KI*?`
zpvX*QuNB<?p{V~p3e2BGOMHY{`WW?aIrR7tRQoQY!Dr&f8v5^EC|!d*{-|C5eFy*9
zAEEyqVx9I}|J?>o>c2OGh5GLW;{3E~`h67Hwf*P(gp&UIXQb&qB;{`E!#|SOt@x6w
z|DI-qJM`Z#@#9theV|?cx$@Re(0@M#>Tjd}o<kPD3C0az@IhugsQ(^J?Z5xlf6@N?
zZ~a$5mjCzGe~u&Mf3^eS&+3(>I_7U&m7k4OU2qIVOPldM8+;Pian7&P%M>?<Bhr~i
zPr(t5{Lg&ykyo!x<ydo+?Kp&Gdmkf!UgrmwRfd4x+#JI&2&JPNmRTA<4hV$JF@>H&
zjP;s>@k;d3x*B8LG5YIhUf^jN`JdO8FBaVg?Owijyeh`lgxv8f^YBT)ZSFo5D@Wmi
zYB6SM4n2jO_MRP)(1vN=mgpF#BRP)N#P~x_|FCpgO3=S&`e-pVKSxDl)I)m6KU4eG
zoE>v<m75$>;r3cvo3`w}j0hUraRW!RgiCzHB&@fNA4to<NXwP&-=5(Qnp(c_h(YWb
z9a3RVwxz-^J79HmQG2`NC(=E}X}Rb&)X^HsN415}AT3;jOUt}x5Bn0r?&zo^a~_Ur
z1f_az&q;Z`6U<du#YbLfeOIEC7k8!(T4^QLcI<eY{7@dm$MoHYkWWW3Lq5Y-+Yu^9
z)N=WB_r}OGa(C4QY2%2BIrI#_e2nojA-4zZ=t_(y#AvqiZVX5CV$>o=MYWzd>Y%-`
z=lZ4XPkddO!WAmQPuo$?SeHoay3mIFi=7;mcFx_7d%4k5P+olRxP>Ew&i{$^DjW%j
zu`_ua@-KB_r3^<)#WrNBdVg^(n%bglO}plWD`Ys5ru=JDanw_(D#^bic>1(=A6&U#
zsgE&d*Rxgr-POu55Jw|jQP#0IDdJd(^5X6mjubiOV2M4~-(3EO1Lt7!a`f08j9npS
z0PXKsS;zHk97_qB<?`=d7|pzKg{+=}BVMuYmLqnK0p{{=8K&2s>*_p1$wK*e^sAO$
zX~@5$DV5}3sI-$gZt3bejj5mN8pb}++ut>+lz->Jx|f%0d?;C!<=-^|CXmx8^3pcq
zzRJq~c%F>r&z+6*G1t!To)(T_D@~3@D*vNW+2YoH2>Ewh)IF{oYtdU?`FF>$3FN28
zx--OM{CODH@?|8YO(Jja9kJ^vj0GOo*O^A1gRu04{7-@l!AsXZaU4Smxe|~2fwcgG
zb5$L2RQ{b+Tzv@nZvnDaa?#o~khZ;Rf()g%Fp<2Ke<gMtRCM&Tclmdv1NZKjN{Z?9
zsO8|?B>%1oGL!!IKzd2eEhv|NM@m~s<Jede>3a%d*#b4(y-NAl%FsZ+#dVro8)i1;
zxrgs0@Ni|7(En4xr;(>2|1(I@Q<#)ewU9EGf8m@+iLOyGAMOsNzw3%DbIHOrjU4@$
zNRO+5GNseBit;}fThDZ0Sp>dINabG386|2z?hh`?{|ZXeDm#<DWXS*ABp0(Ovp4<k
zIwot#c@#M-|1-FoK{>1GpN}Rl<$n=5Ey8v*2D^*$Kb!KFfk7*LvBYtd*i*>me<^%8
z5xkZE)xaF`@46K3&#U~;gy#)F(E<-#CE69DXL0Y&Z@tOCGu-Rwce>{FR`QGegx#Oj
zb#W$;kMci{(${cz5=RR>7*p5)M#{hT<gGn{-_7$}{?}lU3;AD)-B9^oU6lW&W%9p1
z$$!uDF`A)r$p2~Zb2`2M6+m?k&sGDK^6v^OXH!zh|A|nhAF#`tRxAhFj2&s|DL9K?
ze20_giP(ce{x2lOD6AXG{~D}>qsS?j|CR7|562qH-$Y6Mfx!9t-G@Cz`M-ekYV1l|
zfzwrhwCGO8s^VD30qktku-z^Lw~+tcN&feM$u{1&u2xT>2B<Gf^6%`9^RaN`^1ruT
z{<p!!!$tYO7)#A|taPhLrCeN+<bOj?*&_oX|9g<MQ<MB(PZ~!FjwTv!O!9v&WiNy`
z?up_mBb#}<loIAZsY~Hb&+>l?+#3iy$4Pk$bU7K0t;RkT@_#e(dNj%Zo}&C8OY(mM
zwxU%)aV0jg4cLXw>=AzVo1OsVZvny^vE`i8t^6OrLUbbQb}Rq;$#pT7V&(smB>%UA
zQ}y8zu&oE`HzxVt5C4{88Lh*nw;Bu4)zt5$NKCH(-;(72jvlkWk~9}Umw`y&9ZCN0
zLH?iS*;}#wD*sPH=chWzzcX$|WAAz$cBMzLD!!HUJ%w`le;9eb5zE$<jO4r)yTh~O
z@_X2%o<shhO7eea(ml(t%Pr&i2g$pV{69}lt?=vu&a1J8b(H_FVG|z8Jm_cJ<=>rr
zmr(Q6|Ib6MXL$3zUgiI(F7p2lXnzg$>0xkD|9>*c|6Abv9jpfNSKt%!e>YqY`G2M-
z@?d?O3AT%n;}2us{e5cMKVXIY3vl^4)OnI|4d?6sDRW#NV@>*}nV0?<O4!WXrOZ-)
zKXdK>vRC>4M!WofgS{J-{}+MpSIGZck=C1$+kZ;(|IK#!e=j`vw<P~Rpp<|9Z~6b<
zTK=^@_!s@n(%GwOg7Ly)WDfr2Rvxb^2YZ%Ler_MqisjR4Qs?=HohW?x0|$G(=2R&d
zuLQp~qa1$wp_PO70X-d~Cm$9#?Kjc4ubf^Bi}(i|TE*<W<d&ey>BBEOdSJG{>~Y(h
zw0BlL1uZ{(ezmojTloA{E<fyqmS}l;x(boDwx0X6<+*Cb5o-G}LSeaK`?BX-IfV5~
z3yuEhLH}59Tc6^}LA!?b2K^_)er2!FKB7-52c_H=f~CnjbBeR}oytMWfwq9)zy9R<
zN6LTwhbxERzrNkVZQE9>h*l2!an%N4mH+MnE&sKLMBlYi4qBGNpEz~~(%)15>(g6J
z`N4np`_%HFPixM9Th^6B@PBlX|9a1Aqi|j2>i93c+~sC`N~z^0b^_I3wmSa1@^<jw
zokaDKwJ$NAr`7PUo|wUZ{b%LBv-suzq+WVWCA!FeXWhFBfj)HlW$NALZ2F#CRi*TC
z75ulqJOK*Gf9(r1J4fs0ep=$cJy*R58%Z|=3d(=mgq1@hy?8zO=Ft|{|GJsGsQ<HQ
z-&PJSP^z9b*;ME~ojh8ByRZCTNZOT&|C7mSY3k*SrDs(=|7Ry@TTH7n`0sfYFjWq%
ziT|^ceZalEbN;u&|7Dev(`MA~ax+w4U*!Kuw8y5?PTNFZq1vz%`p>6_F`S&%C9B5<
zu1>2W`7XG$i2lvSGX8JknSID=ygcN;UQZX&Hw^xt4iEH*Ik#&5uTA_v4Xj;#azbGP
z@^>QCaBaCtVLMWKMUnq&s51xg!Z?iN@22IwrBY(vXK329k(F&wK>nWt+;!<(9sgYq
zOF!KG(0*eX|F3}m*H%%!-d>k5&VLT0^m<-RqetYrZYR_3ub%&}rzJn1_WWh|_Pm*^
zebDf2ed7Ov^q->sUx6P<U-*A(k^j%*4Yi;8FaIxx|DU99Q90a2?SG`5|6eA}8|dr2
zs%ri}$0}=A&>yq@yKcZidPP6LE9mp=-T3j!#RK#275V=>9w1L7{@={`CF;Lxqg4t&
zgIc%3{~zP8@dYS<H!F{+|F58T_}~1mM7_MvQHqyw8U2a;S={+NdMX{?`!?^X*k10M
z-gJJ+^TRe~<mQ_^H`{OKZ=b<$avpr*pY3ADam^*lh!~b0Z*4zEpTm*7JlK+U1lD$a
zwC(f$QXa#zx#~CWVN1A_-Zpvkr()i1jHs2~+v@gvYdcK%oRL@#zj;O*%Q4WLR;Bc|
zww!}x3)U5!Voa_CfunV{a2-R`j_o+8?bAF5^Avw`i5X;$C+2U3T>Q1dYjLx0(;fbf
z&p9^MJ^qedI(A^I#PPZE`~!c-kDT)}n6`^^hf3w^@9RGFt}`X9dUTbicedd;Vwlcd
zRyyN9mJ~Vuwk=14kF$sJ5*$~vWbt>L$eC5;`PY(S94(2Vyqi|Ue|URpGD@w)a{QeQ
zljrUp4fbWG7x8!P^hWY2y>|t9cMvJZKVR+M+}+(c@Lvf2<4Nx<ms0v>o~%gtyITEd
z;!o=!fq{SQI585dvNJ?%*W@{f|8gv9gJ=Vc<IOrWe|i2n{@SCb@m+Qe_m%Cbg>VE%
z&-iZ!-<5n*g8zFGwB`7pR>XfRT-ZpglcB|_W%&pGYx%w}1h!qYQ##_mjT{db@!!Jx
zy;u^<Yv5QsKL_$%IT`88@ju!D|J~Tij!|Zg|4}T=Idzo(z0l<<Xmla?AI1)S1iNYJ
zec*pFIbO!0{2waIy?|x+Qof0ggW0RdOZ@NQi&skj6!>34`5y!dSByTH>nF<IzXhxJ
zaK5n5fd8X~PhewwLkIqB!(a6<9?AM$e;n`6&iKC-{9oSz|94?~F6V#X|HnoAU%;OD
zVp;kBf8(E1%5z-jPk2yO$Wv-%iabJ#R+mqFRkTTkT`K?eTT@L4`;0N8^suXW-T6D#
zeQx&d18TLjSL$ECQ}M;?K2_;y*fks*7lZJ^GPQR?kW;mkqT`j{3cpL*q{1u1(zWcw
zx3pvIu6M$#RVm;V8vPsMTU?Ee$}ewxmBrpKm}jB#%T(FIq?b+DIQ)7TKfbTwt5!LE
z(BJa>4qCFd0ezmtrE+?GqqHvwt=}eXgh2(r)$+FY;CH*^+hfn#l^6713Ts(q{yEoQ
z{%d8EV%qy$gFs7-q4#<a9zK4v^*)mNu8=9-wizl1W7{&(nwCSZ$CN7}xT993pvR6Y
zA4L6;|CZ`_p?OrMzw^gO@{Q8_#lE65$+eJasq?o|u+5^EmSy^-lY`osoDp9OY?XrT
z9cTX;*HtS03b|f^Tp2?im4e<l`Vc8MLK6Jff1x?$Rf&J@Hs>5Q`9B^E<o{?ekpEJm
zQu^TkIC9bZM*ce&%odbhJ(YuN1vuBYg<sdoRC3)1!#$m<<NwSe|1EReE9CziFrGun
zt%?6L(p7c*x5YJ`@2C8q2PG#%#kt@z8|-Vzvr=&Ho$<7(<o^=*KauZv@PArW{MQ?0
zUgH0B&cXi{T6}tBOop$O_%{mwg%#M;YH7WU2Lks+5B|>ulFIyVh2oCzuY-H*poJ~r
z3FN5%QZ=&x^?q^2iu~W$&i}>Oc2*^NRHEN%N}reDl>Zxx{9n!Wa@v&(DkTTn<=A0d
z|NZR5^_4u4|7UQX&rvA^|964KP+EZ768|p%m-7<;&##mmDwX(uIsD&EJ2Ciw4sFh!
z{X+7Lm*b7mng8d~;;WwjHzfYAr)4;vbo&zjcTxZ4|0xvHyZ+Dl|62I}T1Nga1q1oN
z56o`Pf$Zfx9FKvEvC>>w<o}uAb1Cw$rO*cdclDAoUi}{Y*UO`TO{&27`nlAB0;B7F
z<Ns6e|0yti9Wo>T&tqSfq1fpTl27kpJZoZ3XWV`f9s|Mu*Rb=$^^Cz=|DW$YF>gEa
z{|M>6QRM$;nP>Fgis_e=!g+JYf#Tgz;yA}w6aU|hEZ$D~-uZVA^N*ea+fTIf|2@?I
zuO$9IRt5hbqsD!Z`v0HU!{q<pV3&J0{Qqk(`ww_nDf}P9|Bq&cwmXZw_+zM&iv}AI
zwO!o{l^!PDqa5ER?RPl;0q6G+e;Vh<N&88zJwL+P>iSPyU%+v&SQd}EhK!e~r!acT
z^qI4}zAt<7RieI&a^KDQ8=U``<2_ve3CH`meu?A#T>lxz2e|$w=RfCojO)iaf0*;j
z9OrOc4_p{s+f)pn;P^4u7Zu-mzO8sKF5+SQN#r4}-iy<?V*K5lF#xB$UduJ{%!|!T
zA}(dLUB)x>^z7lYTjN<O`!&S>0ndu%w4KGZ$GLH&a>*~Hy@hm?Z+?X~&J}4)y#H51
zYL&x4&+?HLH^20oYI#;uW9K#FF0N{7=^prQ*zl2~#*7^|e!|2_lUt@vo6$O}2;65$
z{C4p9BF8(p{u1Xeb3DNDHI6|%8_MxAXhZYDJ9##eV-xA+#TK4H!$eP?pTeO5K|Xwp
z16fV7X`ELRSJ{Q{%B*qPwsV-qwDLi|T27JA#Huo6i7?Ou{OQY!wKS@&sm(YB3~CxY
zq<N@K^bVoz6O{E9%6x(2b6kIc^BXzD;rBTU+kHHL7T7+*0lvOV&sTH3o_EkD(Lg%A
zgLlffbdzQ`a<;yIlj8=iiPN@+>pq6WZBP?G0?2_~R@=X!vG-Bjwm$`i&vX0*NnhZ+
zjN^|uka0~?Z6B)cx_58|254$)>+1ReQ(5G;j{)<iIerhk@8v*B6AhtVq8qf4Rvn&i
zE6c!3#F~I8XI(mkZ7=fv+vM>n&R+~%5>9XBTHLxj+gvXXH8pj0{rlI~*LKan@Q1+m
zJg~~wH*=lyyvS4GE;MlDJieAV*A?R<2i*nhD=e%{h-ozGExbgz-{OF8h0hi7d8nIn
z&QJ06eeu3)))byf??>q0zot_8&k_G_4scAejvS}DQM@mcWjI8otLs#v@jt^eWlgv|
zl)?PE#EY7`n*Q~5ozp)_xld94Gn}90{Cdv&N&g0}@8J4kuK%6mD$4jTj(_F)3C>S(
zewy=o&Ko#y<ScFO;%Fu9n>jBnruW%=u6@rt^UvR>@AT(*ZvI~`zBjH1=`GJV!eIFc
z9@Br0gZN$2A0Z9#^Y`uXuOYu<9Kuq>M|cuGlqEbVf8pCo9Gb?d{4JbMEgn3pHXwuQ
z5i(9yHz^gWFrSSY3`Yi~vo`*dG19o*1aNHo3eUgB`Rg2hljm~J_dT^uS~+jxei6rM
z95&54(lhScnz<jtSvfEc@zZ<r$lsU8x2<G+@@%7dYul;qCJxefxc6D{eabJt&&v}g
z^Y12oIefw+KB)}y%k#?dX-{7UkMJcJEuZqz(ZsVM9KD6a5BO5UpLHpzd3nM&ysj2z
z)DddxthqHcsrI6^_^++wzlV&EQ2tTg9pikQ^FfX|Tr1CqI5!sWw{z{meTQdNyzef4
zDx;WR`*qoU`?DU(D}Ud9-3xr}ak_!mcOBmM=bj_si&VE251;iItS{*!<TtLaUw!|6
z{Tu50Hw+k1KcKOZukfIO1Dl!#4H`VSX>jw9Awz}^ZEhYmeCV*@Bls_5{KLiW!bIw`
zy5m29<3Bm3aBn+R+4(%r&*#{}wfgeCTvr>wY1qioW5-YFJwe;gdH?t1J&XkZ!udDc
zt3$^F$G>s?Ke@II-ok-?OL`HVk=n+zN7|-y_zk?5cQd&j!1Z7b^)2$2zC*O-(!Kf#
zTyTXc;L;KL^drO(->-1o!?Uk(R)@Tf<LlhN#MwIf7aZT^{wdDabEZ9MJFD<H&g$DQ
za<-0hq&DXdIe(1fM?51hT<HsKf5Z9zvjEP9;;H?dKk<28!$2FQ!$*uMHp{2aNNLJ{
z-VEG+2mXNb{hS}*EZ*YwZVvJKAZPWI^gV|&G);PxYs@PyX&3aojk7wy=kTEI3eMGs
zy40{XzPhFeyLHHKY{}S{Bg`{G+Yn^pAGr7@u7AxzJHIfRXJa`0*1d^??^kLU``sSF
zd*Qo`=d>IAhNt!_IxO|gF5w+|JGC9Z$FuKqC=bta&<>PNsjYTDXK7_Rah6t>bNsGC
z5lz2}{raN=1~rWu*InL^^YA`kcpK+;a45gvl;GXQ^@q4tH-mf5zl1;UFek=$UcTPS
z@doa1=X?ui@JcjN_Q9)d0p~>=uPoG%jIT`{pPf<$MZ8K6y1V)XW&e`H{?0&nYCHS|
zj^{bRJ+;A=&wX5fi{nqZ{w8PXQ8{FM1$zxiXWUDaN6GUM&N<CCaF5<#I6j8leXgES
zKfH$XC7gQ=so;v`Yja8RyOHx^GPJIhpRF6b>k$0HbEIcK=J#hD{h(ccj@!64&1#Ml
zIChht-@OYsuHvB1rf>HjbABuDBS3sY{Kk{wZ+ji%`;q$I<2g^~n8Y!KJcO09%Fn6&
zb{)?y=3NA!<-3>Pm7mq;&=!+l<U^#k2^>w_k1U;2nfd*Ih~HMqknCyP<TT-R9@>7w
zmHjJe@dgg*B7HtV-k;>y!}Xb*<vlWxV1XwrcouE(7daybN!L*i4INvu-4HFJ#V_Bf
zw)b)=t-veMZ93OQx+U6e;Q2wG$seA#c`r>lC!2=%b2#>K5G>y#b!kg9h?kvyZR;o8
zp&drqMArm|FwEkaG!?Gmy>w6X_uYIB;gBDeBi#v6wmnc<{B^nAB;IxY<=c80-|TbH
zP3sG%AcZWf$?tBCbCAs~9J{GYE~<D=+XY~}v5T~)EN$AR?gi6+z#AZnB`s}R+@?GJ
z_`;C(^NhCim!7fV8+XL;87=4`NwPYC>34}Hh$3p^xF)rT^BAq9axlNDzqZW3JZbT4
zzNo^60W|WG5h=CkYKm`9X*-p^$ZGz!wXK6&Y|_@Yp=~>qux7NQ*`DcqH1+tl3GieJ
ze{<6Bl(xBTlM^?I51q;z^9;_yJGR-N7twzBEOFG>=<HN;GQU3=1!eu48tVEtj2=3s
zaq-#{H*6A)9z#lyiZvy7gKGNM)D3Q|A5>G{fAE0X+UEME#`?P9!<t479ynyskjDA}
z!v+i;Hh9R$v17)L898*+utCFzjU6>_{=!8|mM&YqV&$sUYff0V{-lk?5=Dsr+S<W`
zvf6&N^#hxm>IXE}jTkX>Si`^(14oY<IlOVy$WhZ~w$7S8XRcqdjzPkqE(c|Gb&V8m
z`i6!k02n-M<k*QVQ@b>okn2H%nwv+C95rgRt>6AxW20^Jp+koa8!=+SWWIBQnze?i
z0aH*LYr8<h*|)M!RX?DizM*jd?fQWO1`Zm;*L`qP(~u#92RAnlX&yFo=+NQA$!+BD
z5hF+OKY9%RW5=3V0=KcIU;nzMrWVYsvlm7gJ^!W@l3q(Le|{Qj8~bN<4OEnV^@IBH
z)7a1cMSbJIrhWtZ4Qgx}SdS<U96W5)SR0O0rp}x*ci#L3ixw|g+PR#RJLuIkWc6A9
z0sZRxHTECSFmT|&LG=Uco9wYP4FHSLW5$i2uF4P)Xi#5YKY&P0v`)L^2(4-nFS<R0
z2I2~+;!Z@XZ=g3c5K=8(URb=e04&=N9XfEuC5Kw}w9MGw82Kz%u<+3SqnGWy;=tj(
zmmfTI;P}Ez51)SQ$Yl!;A3JsP>6`Y(-QJBSFWGzkjQxA}%s9UHq_fXmvfwh-;oNk|
z;loF+ZMp2&flIDE&{CLo@bG1auG@d0<%Hwc?mu|=+67mhi0@?k!-H2}&BJ2{52xqX
zA33<crS~#s5q;I(Yv;5C3>&Yzd|sC)dk!3**V2+dK6L094_aDgx4fpYaLJ`dj$M23
z@D=k~4t7Pm&{7P0_g=kZ`HF*cT8<V`rI@uXjlI67j2@x{06n}s7ReSaY>~hRjvsHi
z;@FYvj<(!z@Y*X|mb7d-?Rc@=GEfqf>sn^zV9sut*-j1LT`*(+MQddx*Ja5P6<S()
zNEmP1lO{nhvpgK#3#cTX*)his3G%p}kM1oJzGHbgH+oEW`H^ESGP&j8x<zXbo-kwo
z+JkfFCf+4{+KZTz1GM*QnYH)$b(bFBd*JB7RkL^#rOYeGo&sCuwj8`@Hk4`4#EX>A
z+__yJM<(gbYa0vQb7*N9hw@yz&oBon<=1^?%ZizG|8{w=Z&&pCc4e<`SM~aKb@43{
z(LG>`7v(W}c)z&9`&`U>%0DM^Pw#WO_4GccTu<+F+V%84r(RF*bNco4zMX>I(`QKq
z`YowIza<sux1<97mQ<kMk_z-&Qh|O;D$s991^O+iK)<E!^oy@o_rJEp+NN@Rh~wA9
z!46h9k>fm$EByj@3iiRY3H(LG*JhSCF^6aUhBaW_rCm;>XrLEU+k!7lnovJ*KwZP2
zhI$$$0~_lb8=LAI1`eXp60rsi<YP=`48sxlr6s~kn)>m+A9mz!f|gC<H8l1gF@Qn~
z4fX!g7^$flHM+51zrpoQeDRwH3>w^=#>yJVyh$UdZGrR$%$7hmht@`2ZN}41n5UND
zfQ&X^gE6yCuYJbT+L7JAh}U@g&~KuJgz3@7YUELt0yAb!)-N8kzb~fsR7)E)4WpJl
zt9WUDlh%A1XQ5A=`qbL0v~m0^_m0UpuJd}1C%Z+fViCPXNPW6yVzhGDpR+&vajw4{
zsoE$q+2HAeCVNLb&VT8T&?lpZMjvi>>ZM&$xGdRB^BBFJDLwVf+GfzVrF}_h{pnK)
zOCEqJ^}BcTRy&0@irYBe%3;5pzIqxT{V`|k9DNSf7hCHHSL$DDmk`(MxW9`-+eTSv
zvp&)fPBsVa5~(Lv7NO%M%PO_4OTD&D^li7&kJ}EdPVE?}?9SfX<iZsCYjd!a*q^g^
zZQsmA<vIm~wAaundY9YRRS3OiUd78U1@`el1@J1q4rx%;q(Mf0W8Q(@8yYOI6yTGq
z;UZ>z*-J7`#P64`ZI9|V>|C3{{Ko!I5kKYtxMqPK;idSo2Z?(v7+=F_U14&Hqaqza
z+(KbWH}OyB`Iy3fem4{lb^I)iKd&%@-|flZvZf$Bm#4RLnAv1}jCI8S7QYjd2Afwn
zi|dI0;S~R0S;0HBr*SUl`tE{N{O_1;Qz$%?o}8Nbq+<{-)u89@uhNSif1LGFqN!K$
zL>gBYoPS{XRJs(x1t6YP&cS&S&a5=PUhJ0ZOp<;n&&uiZ7;>RJI2*H?V2Q4_>s%9M
zC003cE~fK9DhF4CaUEM{M+&(s-MZqYb0Cz1${}VxIEO%=duM7o^Fyf@wn{;cb>zSN
zh-cNL7jtKLn#vmEy-)IbSgCyHvx>KKSgc*nf^j~M`#E&xNq2d<!m8`r3UREH>ueNf
zTSlGjE=~C}HG_Jhb6L(qs3y3+jQbWk^VC_adi}dMNiA1Hs>onOk^im}8vJ+mNAQ1i
z73tkas}5{k57qtVTuroZ{Eylq?d6}8mzwghzKZg5$(R4mL<#<zGN1p|dnS$0O<9-!
z(ku8s1nO1GfA@Ek{uwlI<vV%lPJyF%QaJ?w$3wM_p{6jc<AWaV<iGpY%`EcY*$;Kh
z-l&%U3uu^F|J_NhrqIImd?25kXtKD6GRq&&XZ}SU4I9@39aET#&-)4}Fq>T6Wv+6N
zT51jH?v8Y>RV*jfBh~X?SvQsQu*_>X1-nvE<skoC;FtU98Q(o8$3Xiqx>rs=ixk2C
ziSU0uDTDv6STnJ5^7O?mkkWNG%R}}2Uzzy7hZQMKU<S(>g-!6|tTYQ}ZFz=0TwltZ
z-9~u0Gx7h-GXAeARL_6cc09^3))nyoSdsrHJA_p+xNnyGPr6Iy1X4~!eq9;Z+3?lz
ze<IR4l;(U*VJck9`9Fp{s^R|<eE(bMUgZ2giFIi<B>pcbbT#I8MQ0yfl1-Go4am=c
zn->80iIlyMLH_Fazm2pV`M-@~s^$L$%)V}e_Intd&-s5L{J#^LRL}oMXsg{#nK}RO
zq%OW+_k)Vz(NzC`fIGm?X(e948YlAqeboQH^52>NIsexr{<l^vT{`V7>?-nqPvXDp
z-@1--wfui$;{O4-HH6l#{J*zwoSbgaO`&4=)5QN{tS0kjTzKUFO}I$Bu}}Pe8U8;`
z{ku0gAw^eI{@+`%^aACr&lY7Z*`C7I>{mEKS^o!R!GBximBQG<Rxr2zx$0@qe<Lf(
zTK}r0|I^GJx)V+W{ol^|x5shYsgC~NEX>JTm~~U4|Bnlcvg7OoRUQ4uVnld|9k$*M
z{NHD-oQK%y>I=aCcCH_*ggo!RP-w~m{x5WZe^vIERp}3l$a^pORkUYIzdkR27uTit
zozs`{>^V;Pn^OLk^GZVAS2De=FYi6_{!~1PwtBpaYs-qXwtu75o~IPT$RqHJ-<%GS
zcb-0nJ3srpx?rn6hcwCy45BaK9OhCl$Q3*Ni}=2Yo?GN#kKG<e4s(=mtms)pf7~)m
z7p3I6n=)ur9n_^*=4GDt9qj{{PiYl{QXAIxusu3UHlBTyNZ}jt42XP_U)d50t3;F`
zlyPORRd`KjuhCM?)%bl6ey7V*M$adB>ATJ$IO3{9U4zsQ93qx?;${$IS0`{SPh~Aa
zo{O>an8jCBoa}G7T7x^gn5%sVDe4N3u1Fzoq;u?E6BLb|)1`W}-h*esA$Qa<M^`h7
z6_vy$_Kk^^737Znb180lawJwmt+vl!j+Wdrb?{Y8%+a&u3cuI3rnNBn*3}~H^ZRsA
zg22A6P>Hknx{8wPG`Rvotm@?1^y1{7D>m8Vcl85hO4`Nh59P2`b1ju!(^UHQ<Lv6D
zmhGBGuDa?fpT6^nvFcI_&;GR-*?YI0C}#G=trf0IDju%e=qjDsA(VG_7LZB}Jk>g8
zeOGFwh*Dtx-{*Y~N~QFRJf)+$F7!$0n~+T<HngBmBTmHfO`e`hg3tZU<AsJXR$Q6d
zEB}m_$K~P`gs8ot&6Ij!@tO3D9<_BZYKB+xA!>=&2JgZa7Egpu`7@PN7xU0kp~E8Y
zpqu4-<+Hv9`6dKWCj%Ba?`kMQY0WT*jcZJJ7|WG5v{Xf0WzSl!%`NO`LL9x)(EnP+
ztT9Ty@-AIm?Ls<Ox{?~DbK8fY%v!I)@)oP7X^T^CmGQ8_S=(Gy#MsKQFa*RxD~{4n
zO2n$Tab+zL>s%ix`PM7zb=a(|DdME<$6Sry_t07YYlE_0sU4d+LQ9tNjaue<9}&vm
zYdH)#D9J*|hWt?4L;s6MgwX$CY0qO8UsZ9^Zl<-z^-5gR*d32!9TN9VcfDM#dfF&l
zKiIv5EIHOw8-lef?3~(vLjN19o*YB}4=3F~?sEO_YANcm;gqL^uZerDXQBUl+efJ<
zRAQH@k>p^G<@#T3m+ODmU(5CXXs+wh8X00y!&R>Tn}Nn$8lZwY*p;G3Cd@pW-rbdO
zVdUKi?j5Zd3vNSs-k%=V2(J4Y#zMDP8`&L})c@{;WcjW;EUd0*Q=guw|A*6Cv21(H
z4y%>)|9E1$3eE(29<Dhzia&Q!8V9%R5xR4eE88{j)U|cwlyz7AKZ3YpxYH4}ufZBA
z-hM-^jn+YP_FC<t^!Pr$Lh8k+lgf*4mFj4ZnUhz_zj;K?YN3c_3F;vE6}s5kp!}PE
z<i$mwf_W;#p4Dc4XO)1^b!r*g0>YrK6lO=W)HrfT4I0`s-l*Hvuxd%a-|h+LS%}qb
z!WnH3TP-mz7W>A94ybO#L5TC<`bV*zdbAYerZiECT!G15;^eXW5?Q};{cpW@*R8PF
zT4S4#bnE9(u#^hw8>J-br~9l~$HhZkp}o=i``hY&*Cfu6^IZRrA>VPydZGRw4LpW=
zo`wD&MomylDbw1hM*^4iS;`Io!jVX~@YQgo?7Oay+QHr2)c@{K7W%)LvsVA%sq7kR
zlPO+F&~dbUtY9d4mh`_n(v`w6E*+<2f;`YhupZ|j^#3SsOZtCg@nt_CbZ5A6Ks=E$
zhViGx)}a2EHhm4{`o9&*&V>e{|64du!=^Zm68iI->;Eb6YZkHGOHKVhg_6e*w_oDo
zEPj=yNkB9P7^m^x6|}Xij3u4=e;UuHLw(B&{V#VLcwXI@UpbDhtL+|p?m6C3|F`n2
zT>sAm?iR{jj4VvzcRr)OgV1=P|HpCF%v*EG^}nl*kHog$kI@D9L2{j^3E1{$Lyr;M
zk0AC^@S4l>7O-8Aq_7;i%GaU)=aPOIwqxl(oc!GlEMqO3<-j_SvP1tHOa1R^o~s#W
z7!Mwy|0e^{YGN)1rZvdNN@Q#qX~zQnIG~%xn|j`;|7Y?Pw+Eh12D1V<%p#Se7q3kJ
z+Yhq#*?Lrq#0~{&X<JlkrNO+<`%&sc^{u*8jcRMay&Pk8+R*>@wQRw<E}ZXNS<hH%
zGg~5le;p}N=7$i|ywwrL>T3x7ul{joh|vF*<9>$fKKDQL3#^_U4kWI@8v1`Un7H<w
z+N3}4eG~fMy%sv^f9tAxN;qw0^yl9F7t{=DDz%g0mFj;-oBaN}zhfg;>i@~yO+{X(
z!d><MBp_7UUER&S9A^?|ICaxC%b2{uTc0(i+B%NZ?oX-yAA{7@@y<G{CKykS+KScx
zQ+T5cIeJl_@=a*;;b%FyXUO|h%AQIdx&B`PHtPSGz*|6mS5U%io()5iXLG3k=aXV2
zwWFl}=kaDaGOzw$O#0COi-A%KPY1hl{qNemQX$&^D^rR-fL@F`ol&Pkhp`4%E-Ro7
z<moaXonMTpLz5bNQ@TG9nnviX|EB}(bYPxde4lIe*<jmBX(xhVN&j2AQ-xZgk&aw_
z3!(qlrElgL$iO+QS#|=HTUa=iv-*D*?pOW!JrO?H{tx}{>iePpcOuoBiL3r!f-czv
z7l*Ja?Q(co(*MhWSp6?wcO_X`fUUlXd)pUV;cf%Ze;fUOAv`Z{|6jme=>IiPeFvOY
z|DOw&bN#=sumR~h1>QMgt^Pk32t)s`=b8JcZ7*C5W;2;YrT*Vftc&<l|DVrsA(Fcr
zZMvV4qcN;|X8rD47|V!@D-O0WhP8y!u7C=&aROBTA5Z%K<PQ3O7j!%f#jb;L=K#ZI
zxKqz4NPnKF|4%Pm-;Ms?%bQK;|6NGWrHqbUf&1MdQk?|f_Vf4K=zn#Jc-w<;Pm~&d
zqy4Y`cg1ekhIW5iEnW69o548rzi-v-?z(C(#C=`$peX5ozjyYAj5Ucjjw<`Li}r+C
zPMu--kyqcSuUq06{zh}o^}nlNw;(aIIn@6xls-G@Ix(0*+|d8-jyZ*T=e{VDh|vU}
z+?%Er42A($c$7r@e=bkd|MuEkV{sBSxS9C2ksRv{{Xd2`eGSq6&-MR_$dLMfA*G#6
zt~-#A9l)~$jWh{q+6?rYc|L+#ej0IxGkUlX3EGs}8qGXglJx&Z;I~Gv1nvz`z&%ul
zqY=iU)i#l%dymwhZKm)>?KYCugnHQaVBf-W>RiU!*`fc}BfpNLosNu${=eACp-Acq
z;K=p=B}nrQBzZpazY|#w{l5xn-j7@_N5W4+))#}R`hPoDClDv}|L*kV+Dz`vP(=NI
z3esdx?Um{OZE#-={Q5Gq)&JXi(EsNXZ&QkU2M|QKjFV&D2HXFKfOb06K9ruMDWd7>
z8tB|wxV>Bbe;sdbc?J6aN;rH4qlK3jE@A5Z0aij(|L<o!^8=h;17CJArl|gZ2Yk8`
zm~Ucr#Wu!fL;s%(2Xg&?1nE)#?<L3gGah^tnaSJ#%h6BQkZuK<^fCB79r~O>c`MMN
z>i>QGJ;u@3P-_2I(*O4W|6NJ{-vZ|!KzhE4OsW4L0l(XroZMXa9PnQS+^=P_Y=6dJ
zA7@<u%Z01c&Mo)AWA*=+iu(TxNc)BCF7jN`|DOi8SEm1;qrN^u9s4=H1M2^;;63m&
z<lv^F{{JjB>vd4`_310|6?k<RSpS|;_Lq?VPcvEnb$F)UlJx(Fz)Ai8G^4;z0QFl_
z`~UI6cc=rOVjs(|;OB5D9;u=KzePRy7&z_6_rdo6YuS^g@1d*yUyokU!Q3`UN&he9
z**t3DVsyn?-t?nB`&OT!iOAX<U~t!7b<;ewx_dSaN&PGJzp>QSE2wSqW&r2a$k$|Y
zTE)B2|D~2zwRo84Hgx4AAXuN;54rw753iVI=>5|v{XEXQDXpacm%){>Ji93A|I>hW
z9ddsvDVCylHd0@<C#|CXUjyfcQ7>}+zXv^gKC-tr>Hi(=`hOdmudiV!unkJuay(kH
zr2j8N0xmB+2rQxh?<CIc@OLzadipNb`|POyZ>RP>Obxyc9lDVg$lYc7|7PmOWh}vQ
zuwDP_?-2U`wSXM@|8gX$uOZj}zmI;Iirjt<|Cv4f{s7%$`~Odp{{IGRls-e99Y{T0
z%nGH8nY!^LdP)8N9q{q1`#944=j_e8oaHH=h34<;p#SfH)^EcvVmGzr7;j!feVv4l
z#5<@L>i=VCpZ8H>U&A(P(2FD*o|*FAl>AH7vzOTiR{tT}|1YGc{(KCG?@fN>w3o76
z|Njeba{d1<uKxpU%k}@GCM9H<J4B4kZ2vzA_ufz5g;cszDL%onJ$-NgkI9CyoXeK%
zau#q=|L@I8`u|r@>6=CU|6lmmg#MqM4Z!1OL-tK-=O3}OgZlqB>{$D8Wae+spZ|hf
zkIwdF>i;iNGyg2LD3%vyWY^%?lI#CJhr^-&2W6jT5>9j0oIS>GLbMM*YVgtNi+VP?
zeJ}N~1`c<pfAncOlv)Evlm6L)G<VcL*V3Y1j=bH7{y916pIyD`pPRs7GP?A}-;w@#
z5B2AA^!!X@a~R(h_0Kgu=%2UY_jVI<ei1VL2K0&g=d(%w+?Vvv(}fQu{d17-`h)CM
zc8qU~`sYS!eo6lv<UaJzL2CcwuR#Ai%K}qRAbHv!E`X=s<SX_mzD%`Q=${|6NT}`4
z*6c76uq+#0SeB`OW@Qf-KFVLTKmV2%lltexEZ09nvd}*tK~H|Ja5J^PHaj5;{qqaH
z7k484-%ah$iP?LRy+5VQ%US=X52BNzZa}MzMo!yUKm29n=dY6dyboD<j5_uhTJ%kP
zNAH7b|HASlze0YVMXo=^n=c_hzI_tPKE!wU!|W&a9UxJDo<IZ4rUms9@}qZF#Cn*$
zT>h}^`*jnV;5|ux9s!oftFQ3q->)B_H9~$iWj`%gJD+1BU03<}2{3+*-q_m;yRy}p
z^0OvWe*O-)UYDIpO}-B**5DI%F#9^Rn4L|@&d*Bnvnso*Ff8-?Rmdj8k5yS?Hj@3Y
zXJ;+h<GkrB{3eJ*F)|c)aUJhU&rA0{%b#0fo<rBtjinVJ{|i3@<JY9aU(<We<HXzi
zP5$0ox&|$N#&i@Tzt#>BImXCT_%K9?kz3@Xr+{f|IecQg&Y><nh&RSFmZMSqxpG`A
zEF4<l!q*^0NzVf!eI$e{aMM=TF_@2|h=D<1;s~C>G<opK)IpVaA5Zca0bPEVpL72V
zJyP78Oq*|5d9-ypYNmfhK$ws0Irb(#mgXBr`Lr%Oveh-1kA67LSIGDI)k8;*0X?zI
z!Et`e(PA8<=;37+n7VI@DYYJT4vyLR=eV$cF}`UY`a3xO6&7u60=|nGKw6}YYkv9x
z3<eIZzD=F8=eZmWDF|x&E9K>E@H8kJ+>oES-;2*n5|roDv53ei=fAYf^9=fWr-XP{
zie<h*CsTx%hrH?<!iOZ%=A)tdTLfQ2TIGUiEhBgyIpw3bQqCvc$$yN8Iey^ysr=VB
zL~ff?x%}%ZVl4lBu1~>0j*x$0a9p8t&_`aIl(P$!5zmfJ_*9woY*5M^Ney^H4&`ep
zbj{m$N{+uHQ~4|bMBX9)T6LW@Bc&bb(7GBU+sePAlaAmzCgDCR%D<zYU4!GgCHdF7
zW~z{XOU>n9TfQTt!+^#(QHB<qvFVMruI}XD_*&>312I(%?TCJ)Q2w=dIrb-&+<DI@
z)+KlAi*aOgmrgP2(bc~|3Y$}m_=}wo=kg!p=(+q$r(FJn%hp(V7BTcR=p4*R%@O`l
z)<q>gyrxX+=(}}4G@!X!Q$zmM7N!XK*CN|Be|OqZdW6htp>c#<zA9Vl8|6?u9piEl
zS??UD5f0NjZswEj<loV3bCLV*^W$vPas2h?xuf^Zq?N;#JtoB(Nv_JjJ}+ZA+{tKI
zDnlQb&LN~C<bML~GUb0FIfVQ>jvb>D&JzmxR|fMj=aB!9%0a~F8kB#>z2<`9BwDsw
zh#Pp~euylzz*GHL^p$t4$Jw}!P-$@=1D(du4jV@f+J`6gAph=oQ<DF=^o<;&RsJ0v
zQkt}mIs!J2c6u)VmSM~V<nQjxS{LSa!{1q8rTnjjj@p9zaV#VDB4|`YFLNp|E&vlP
z9n;d2e(8D`_JMx%;<Pd5@;{yUokPgKI!&2W7KB)tRPsXp)nbnGI!dZE>Vu*el5#ni
zc)9#*Y404ImFf7O(y4}1LWgiYlDNuH$iKV7tBte>=sBccRCpVhLJ4yWR==;#p%vb^
zbC$B%N?hCa<H^@?QRQE)p#012K~Tf7Jnx)!S4+$p#GgP+<=+w2&cP9EJti9H^N-=M
zN4<i-{yZO!Rj3)RweY7ceOZd7{7)wT1@t<UfBgeO{v9{(9EOlr)ZoR14Zx!OpH!6p
z1@uaC`CmXDOSoG|{F3~;-xBNea)@15>KI@7Ur5g~qo<{{c_MHs|0j`V4^KDK*W8MH
zZQ^b_cx{3n{kYyt>0_{0DF54e*1h~Mqt|-@x#aDixr|qxUX=f{p>u|HY!a5O6QS`w
zpa}WjOq^W)PfPND4zc!9dgrj8zQKC_oFTUpI-kUGl$eKrGvxnFET$*G`!jgzlYUr=
z)c*^KtNfn@eFxJsZKV9J@~`Ic%Wf}zEYOWf`bzoNi)|E7hax4)zg}yD_*Fv3!(rur
z1o`Vnqn`5HtbBD0rW!#l&5#r2e@c?elKhXOq$yY}8Yp=daYFv56D#C@D)03q3HetR
zJBC(9Pn7=+^q+PipUy(ugp7pz&w_G#S}f&$7JLu+UrO9bNYmUT|0g6)&rb3`yJP0u
z?MBX5!M6r_o9^7bid+u!*B?8s^1qE-&gJh4;5-Br2jS9ssB<>G;U%O#4Vz9KlGlKg
zUDb{JpM&K%<o_m8Ur32fSjE);yQx8rV_cSCx}F~2tGNpKza%{yz>|{vpV_Va-wE#z
zC;2~*9=q~?T@izmfcnE&FW;Ty|2{0~+P^R6d@a;g{@;S6?Z$GE%m3Bgl+aoJ@55gI
z$#(gFEqs43w0;bWn)3fyWaZV!&1T}{^8bgF_%_~5qR-w{{=W|eKf#}tiZ3Di&(ViJ
zN+0?VHh@=SQGbyB{#DrZ-ow66-$80VLcZSv@;6fEN#OPl>~pt*!5?9{e7PI>SEJR#
z;}ekd)kw-Jcsw2W2M~94lK;ijy^w!BmR2K6%Kv(3S_>teYpMLV@HaQfS7J^3kMh46
z`Cp8dQ2uu#6+@8F(EleQ8LN4AF6Fw@Zpi;uAXtJWY$Rpv;r%&D{?}4&_ws)UcB>7H
zQ0xNJd$1edSGc1n|2IO3`Pf!oj}*?rPIVZ#j+5(~xw;MOqWb@C;JXuy8<F9g+TqSG
zc0=J+a7Ow6T$29}kXHHsCb>S8<o~OTdYJb6K=ECyt?McE%h)8A6h2>+|K~~n3HWq#
zo^AX2XV|VD!17CbC)<F1C*=Qr&dR@b+>-n^X1V<T8Y}L-@Tf6U{@<VMzCZ3pItzuB
z*=K-O{U7rGzp#S+xG*U@jC3?)AEwk(vwy?>sr;Xx{ZHiol<ZopNHy7Sz@jBn{y#&#
z_+xl`HM8|P2ftdm{M>|O-k9X)ASu>Bk+YGike_Xoe>GB@%g^hQ{9M~EKl_sWT--T(
z@=$(mV<hQQTwR6r>-VwqK9c0;a>fgC`FSUtxC{9?j=k}NaC!+=uaRK&5lZ|-QGPDz
zL4Gn8%i2(wpY1A4$rfPuyN?C9J`Po%E{w?*X3EdBESI167UgGfc3WY5_9^6N9`tO@
zLVm`=p^o9%cKY0prSfRu|AHPLz}mH)5d`UTe>;7?3w?e?{kDF+3mfu6<V*TI2zT!*
z{55*y4_vgqQ&^p00{|B3^CELOpDpYG=0{k{{7=xp4<jMguQA!VSwprh`z6p%$u7s@
z_Rod0vTqm8$d2*;hO7?VvKGqyqEqf2Z$&PS=ugLQSPM$mrtz)|DLQ7>erF%Z*fr@%
zewX*w&C54Fk9S6kCn-UNpWK3@9l=n?k=v}&1D*$@{@RlXSn{V4r{`b$S3;xp$GnBt
zYt#ECYy{qi^~zXY*~+da*dsL9J{Cg15JBCrtl2_0hIyK!Ws0f&$ZCQ;%%HrfwN_|7
zaaUm}7r`rS0ujW;_I%K@_^`*5?R&lD^*XnY5tfALXPA$N!F^`~Griqy{|DabWiLNk
zDWs`uo=9=~C-zCSD22^Un%Jw+IwJ(m1<~G<W7kXO=~YSAlti(%Kjw8#1MlNW^n{F+
zzpIqHauIfg$Xgj#3WKBO8}bsCkK6_(OgTS#FTvcj4SJZyKAy6n&A||~@f_5X)8Zz@
zstNKfmw)Y6T9=f6B_x-BdyaD7KD`#pkpHk`RVt&N)<yJ7!_KMvYr6;u)NW;ru#Jh4
zJ<6Ev6LM84e=TES71b`{ydb@<lz;tvU0X<f;S8mm-tMj{Hr2`h5ZX{ubSP=Y(oT1W
zWI18`r<SjyUbu#m{Eq>Gv6N|FuyPnm`zz$%J)8T{ix@@^uO$EGqGx0?c`E;-c<)T1
zyw6gpgs{v?b*U1yQZ8#-)~03fUYSx3q>8cBd({N%V(eiq-=vKa8?$4zr-%G&DbpIM
zgehIs%l{zgJOG?S{<S=4#dYS3whFB>p&LT}hf}sQ%<M~7C!f;ac`kZnjwNU1UmlMk
zXJ@Rq64dA<|KljnD?RZB^EPZ)m1s1UwzKkYKT-Qf$o~ZTtD*mM`PXC6SsN{sK9Y8=
zv#qKLTE?cOltbu;&IYns&|o~2QU0eu1^p`ZrcwSap%si;fT}w9XOkx6U+?V^v}r^B
zwM$H-?bFPmJ+Y(wFNLOBwJL|9w9b|PR`Qq(Cgt)!3pllzOrtMhUvg##`M2j&IfQo8
zBi~V)7y*#x{eVA%LI!PN%D);%TbZ%?CjYKgr9RM3l*_;V|0BuSRmGHe*X2?Eopqzn
zf3A-b2tEEN|E?LR)l*88%fEIx=e&&M?2J8a8?J-o>QjA@|4Edgm;Z90Q~nnLuWL~a
zr@t8TKN|@2a9)apEudvPn77r*Pf7mg1L3gLg4bFzA<3lkU)2B8;dIFVX5d(z<bOkt
zG%0^kOV22m|D8a$hW_*-(yu7W|4QU{GcD*=<g|cCM9BZC^y{jFKbQY4^l^6r+oehV
zm(i;mOs={7pN4cs`)4_ps;%@UtCjzq^bt0;%m3aa|L2iI9X*HrP~|W^`@Kp2k5l$G
zuo(u1r&CIG@;?Dc{HiMd%86eqeV+Y(Wn391rzd{l)SV4*TKNx~Sc=fgkNSTiG7<7W
zht!VY=%K9t^L*rg7FUyax{xE6f7f@L*h{XZSIYkuxV43x-QajF8et()GXM^s!1XC`
zdmZPJ{GW<FNUy1-rA&Ic8j6KN`9B|uE~n?eo^q~)_G94ia5$j+@1kcllX%MiCE$7m
z{Fw{)s|m`#F~>oRa{1p+Z?P5Hye7&2A<8_TzIy>#RsJud%nj9K4|GqHhkE@A<a0K?
z>nD=@--E?u2tCx5NYJ}G$^Ql5dK#WV)r7ZV-&6lTS(N{;b9a;+zk#3VZambQIc~!%
z<vnopO5%n5zXY$V)Bno<^Vn5df&6|fVE1DA`ZMTzGkJa=`Tr@lvAvZ3L3+N*|2=({
z|Ec8SS8*OPKL>iWAnmQ~^54R}TvtEnQ}1ekYv9R@D&<G{-wCc-ZkNKtRZ0H!kSfXl
zc}f2FBBg67e;D<B2h`eG4f%<e%m2C5`cv=(x~&`ezb(oCL8NsIyuBa!zqCsDmH&H+
z^8YBZ^fVTrEAb7!3*RFBm6iX`!jX4iJ5v7t44cFi@TOY%{}2|OAA#wIv8!d+WS-~x
zL2~*HJH~$kE9$`PeyFbe|Dx~@yxWX*<!ks#^;Q0#0jmGRdbcsVF#But|2_CQ4#BJF
zXGQtfgZUXK{|uZSm{l+T7edJvxLJ~)eMR{>4GY|4-nC%s3HiASOilq4<>x?^^dCUX
zoj|Mn+y`}(pPS*yQ&`c5Vdp$T$>&iAFNF(Buq&;^p7;Jf%Fj=L|0mSn(^+G9ZZ<W0
z3EqCFgZ@;0-iL+sqj2O@Y>vyYA6BP7zYk>Z#a1PK-k$2$K6Jrj)UQ8D^m%WQK97On
zFUsii6UwS4<n;M9^f@DY9{XEO;e>2hCVjqH*qI%{@BKXd{-$QH%a#-_$fVDunf0qF
zt0w=ja~U<ROcQsd)P6z3UZBk&?(*1SH}IK#C#_Ff0KAG2wgr1(VIK$^Rjfl0G0e%f
zVA!sVrHvyjM)q**4SV>;(Ntq=&yV(_BlXVU&sQL@6=ILfmYhMzVt$Hk05J<#^K*{B
zxto{IEj_OD{$Sv54^sRB&mgaTzTDQMmBKz{*l5Uv5Pk~w{j}!@Q&>mzb26AB$6r4b
zb1%o=8SAc-A^wgEi>sr}_RS2!>3Fkq1)YIvt4{pwsT=J3JEz|jN@9Fi9Buax^>vCH
zT(ewzBHG8aHri9m@z+Xczd#$6Ha4vnL0^4gv`UGmy;Lm)!k@REoE_#Gv*JI7H?H>V
zIByAmM+|M1xoWKVhyR5w27~SFIi#9QYFpitX-~}Ldy?a?XTu_%<oH`_JK{edO|+74
zM&LiG&_ay)91A&wBfJ8F?s`2823oBnCH(CjI|I+r)C{`Ta^*TBhQQzcW+PAp{^NPt
zn%+9vzKlCZR>glBx!cm$!(vK`F(25R6IVcMZsKYtt)Kdox*Y#C=+!aAI0yVsLp$zh
z$A33kZ9m^#@jnS(TtQB&p}@9w{)_+dcKpw${1d?c1m+MKO8C3N$tWNj%-6$}PHa;J
z|4aBU1pj&9v!Db1%Yb|df2X12X2XByW7@Vei2qvfKO6i{2mh@J|1*hqUV49B5&vy`
z*WU#GhZzIg)d~OGXd8+D@AGxOftJu7z5uT(%Kvj{?EQS3$IuEC|CjjwypOi!w&GY-
z4Y>Y6!v7A&gEDmHJ84lp%2C399?-Zlj5C16e=XEm+K&Gso&^85LdC^t&guf%+`<1d
zDDw?`xt0L`!@w^7uLA!YXh#@6&<X!P1pnLU!93tbzl46-N=B<j1MjeGJfk-MH}eR@
z|K6hfe-HV;jj#IuVvKHMwl{0dKFGIe4{<-2((6@lh*CG=KX65Y|1>CZGZ^Rm6aLG&
zZ-8>b|7mc$hmpVIDZTJd&xC(!b|SvYUt@%7U^bT-2y9SGc#-^nMgCtP|DVzBnE;nx
zgRgX+{}-u!<@x_Q<$qe1=bwKk;`@@agbU?&35*_pLL=w7s2@z5htgI4r1LqxD(W-s
zO{Vt<9j`8~6vBR3vX!e{Os$SoZ&nKS+WZ3LI$f==1<+B7{2OG9o`U_!(6s)lb@lYq
zze7zNZ+c4WbIa1QqqmjX+tCbH0n@v;I{Yoq*!qBl9*@xteRV6_sN<^|T$BFseU+Zo
zjWC!p_gf791t--^rB()!dI&+O_@2eLTK@Yr^DCicviIQVgY*_!zwBBDY>!Bb@Otb$
zeehrVTC{0Qt#@hgzp{<Cod4lL=J(UDyB=wM;r|eHq`qnPk%IqC#Wp~180gVv`(iZu
zDEO~_x6L8{E8CEym@;VF$+4nnUxbHxH5PU~(S!d|U6~JF*h;~Fpf}LdyPW^Fjhe_S
zR<6?usnxSG|83I*|6K>kwuz$=L!qH7FNKcn4Ty%++R<9B_whK=>MvzW$ogN|2ITw{
zV>xesAgQ%(2meQ-l`E&0_O?!(54r^UE#iA9|7SwU)~fjLdJn;WEm<w38PD%Bj=u0e
z*1?mLwyy@0))fh&cJxL+zrA|ts<~WaWdvs}`|__k{=5D`9ciX>^apC!bs3-1Pa}s)
z!Bt4KhGfufBwx>ZxVJR%e>u5oo$oz#<o}7ZE#{NM35oyHX|YralduSEC(_0u|Ieh<
z6AOA;%75SV9&-M#P5fUD|1T->{{%dmw)CEuxBBD-|IenKb%55-P+FlE!v71Q=UElg
zyE>HKniGiaSfza#`9G0AHBqHtTYo50pFy=D@WC0-Isd277pN2#Q;z&!p7_6jcGk(z
zZ#-@3m9!}rS4vJxH|PHW@;Qj5<2?Ak9muaH*Q+X~KOIT4zcrSbV&~)675sk#RB?TR
z%KX0`TjO?Y7Z2k1cNx}@C!qT~Xu}?Y|F<T;tKLD#`TqzWHu|J3qTLzw{{!&<$=(z5
z_A6LQg8zR4|NkoS|0U)L2mfEJn0_T%W>jjI&QJVb*3N%h(3SarHto%miu_*>|1YF>
zvo6(tXUXrWSpKbv|7S8g()xc3{J)>p@2jw~-dPp@ABO)oQ0_H&B$fF89QMJhvE2S;
z#qv+5uW~OIp%0bu|5<tr_b2}US;h1-v*7=ZY(`ej{|OnMY1!_qQU)vO6$JgSPF{=G
zmeKzV<f>9Q8%tc!|5mWLy-5EfNOg7epOU=*-F}1Dp7fuT{T$2}WCJtl|4Xc?mBJ?y
z{PsHn{@=ho^~Xa<!ME@(tQ1CNhuH=0=je}<=sgAe|5;d=3IC6Jke^a-qbqr%2V$xA
zB1(59IBeBK4u0V~_b~hd`b_^Fa|kO?DRo?hS4+ufsr25qNZ63VR%83PJZKMceuFt^
zEz=%W9>mCbbg^Ds_g~=L5+)X%^Ve3D+sC@YKi<YnAIAo|;vZ`e+n?wie|;PDap)Lq
zj|Kkj*%O`=<uRO@CH{^*+t%uezxJ>uz5tFEcZa|I9eWD7wXZyPeMR)Wu=S}8(q2`^
zU>n7Dvh%gXzcU8<!MomK;P0xB9fMyBdpx$b#Xs&#ab~6Vi!v1Wch;cduUGKA)YqTZ
z4gR)c=AuQ#e+uou&Y^_A_Q=jH>{wmb)|dDX?*aeG;6Dk?+po(PdJ5lzI=;KkI;sK6
zDV>U6!M*<5<M{H5zxU<gOtkhWzG92O-?7lm<uAG3T*QALU&{m7n>zD<9pCVg=oInC
zU$zVW%|PesfAZh{QCQ(hg}5S*E&0|$3xC7Aym!sXCA2Y|H6s2yN=ehz6h`yvfZ;-N
zSOflH1uI1oU+p=UCj8Itg8vf<|GSF#zp)GcPk{gH88^xCzqXWhy81X}zq#;3tUPb!
z+x|co{1+ARp9vS{!>6wJpFyiJ@IRd|N@x7;<Qs7t_}_&k?`qnI4|Xa)@c%CU*n$7o
zI=vVF|7gemr(N*BFq8kQ7~_)vYw+^!7>*|R&%oj}o${}t&DAj+XWZq{BK*$)|A#xi
z#uHljf5!R>hZ#ZnA6?*&{J%y1A0Yo<cgcTgmgoQ1g`-*5{5us_yj9c2U;gb-PkZF|
z`BgkG#g69@H-DF>Ddm`_jyHMUozIbraZ90;hgW{};%tog0+vcs7y91c($lyv=}EsS
z{uv{W9p9OVQ-Z2=l|$x}j=^tL*b)4m=3g$q5K*ovwHs&wiu{e|VK9y{!;<9LxIPOj
zlQ|2c_c1EsTcM5oBcCXN7b&ghQqcMqo`>dTK5<03@qP508TpqW6c^j>era+lY4g(h
z7(o~uqwomtzrf2let-3F^ocQYOQq0v4BD`?Mj1@!H_fk$X?&{HOT2vM(<meFw?{k0
zw3Z?c#uh@q4v~XjIIV5sABU+!3QAwUfUGNg#?_C~9JB@L*(*IGPpxy}7Nv%)I`-$+
zS=xnHrzvbTh*NMnxBU4f7cZ?;e(TI%i&0QIc<nbo=WJK_9Kj1J>uW17v@M!KUpjNr
zmo>hk;W=mu<LLt@cHu!C<DFp-be5{nM(a@MqFnKaS<uo^ib`p*?);VGaeD~rY5fge
zn^%l-iLsP*bx7@u&VdwmZ7xEu+}V~9-tfQ{FXbxmGKRDk13ij`I7arwSL#RmNNNWL
zUFjFPKpe~`G=i~mY4Iv#MQDs8#y;~eWKBBchfhNfM7&b%F^#$9=TaFy_sD<KW${PJ
zkN3(+<R%w{L;m<Kk0D2VVl1B;FEG>A9AyVK-YbbAIcfn@L~Y2SG1rjRz?TTAG|#0V
zK1z{!D0xu>V_Z3xT*tk&o@%>{vXohat@*I0hMq9Du(w)&g4*T!&!@rJ;ArHdbo4|&
z+mQA~<cXR^d2&3|YwNU7JKE|ve^9{|wzbfetF6N^<{$kY>8m|PIke_C6`^r&2}dQ&
zA$TAbuBB~_>P`RI#_L`G>A!Cs_AkaxVsBmbM7jQRK5a?=x$d>=w}xkbx&9kOiBeuH
zb3K%EHmJz!_F(PI^`G>xrVb&U`ogsfa{U*zRXW5BWjUn>uJhMJ|G5fx%z0N@tijUI
zXO2!7b0l}J3hrE#7}s_rJo-F6@mI@qNByV&cIZEM@(ukLa|E0<Y|x`R^q=>_8~8L8
z?Lp4?@2LNx7bSe^E@uOXgMA$-H#kAbWj7(#I&UE5IQZu}<x;Jr|6KE799Zj}Jf64i
z7~(1lLwKs>yF2R`?nD2L;<@@y?|9#YuY(>Mt{Pj?f3A|PRJnSDyQx>!f8nvB?oxwT
zE8_4szT`@D)X2~?p?l&xZCP<xqod}A{_wfH^O?0Rv_Ryo4hxMQ8Z4K>axw~s>7(wJ
z^q(A3HhpJq#!#yAuW#_(9Q{J5ca&nsY;0rL3%0&%qX>QDw>`dokyq4N^@4fyOuu{-
z!M<Wi|Ao#79~Zq&WAz5t)pjig$NF>qXAKHiq>-Z%u_A~w71Tg}*W`!g2(OZ7%@QK_
zzOa7ikJD5A7|$E^pI-3Rve19dw9r>R)`3wYxNnGl@y@K#dXVcsCCiZyJ%0uhXE+jS
z{fb#3?pN#{9>S=+nuFAKW%1!iq&sv7uM{xEZ@Mi0IOjmg(JNo?mT3Q3L+esn^?>6?
zYCmUEOyoD$f8!}BFb^BI_I<f079I7U<6cTztYVStKUc_Cj!fMXe3R&-D>;*hE2PsX
zaR%3}K|T{aCj*yb434Q~SQ}ggWfo;kB5vqES0-_8g_Z|*(ilft%XL)3wFzeMH!)e5
z^;&UEXmXMW*VCVp_-pPx!KXHJ6(8G6Gbq#AK9cx`lKxwq?zOxaoL?Z7+!Z7ApML0$
z$1UMpV0>X3zx~Nqy(k4{`Iy+{`foCRQMvw`ncjEzGlYJyZM=n8By#;XKY3Km22XeX
zZr~069)%WcBK@&m=&xhne-%%1{WqOh=A!<S3!(pJlj{tin*z?Wkdo=7a1|KWy`Ilq
zJ$VT+s~7f2Kj%0q;mWLaF}{h;i;MNdbN%PeQr1EJ^F#mHvT%1E<EgJh|2aD32$Qwd
zc9S(F0|uWtFVh__oWp1S>Ki@bd~Tdv3e#or#~D>xOFe6m^P8X!P;N(%gDnu(oni%3
za21c-s_1M2M?KX#u6?5vTaQEkSs$9oL9e;^k~w3=mAUjQvOYRq?XE+%s7+;v-*j30
znF8lrcPQ6?qv3-x<IWldxMP}`T)S6{yHte!)AnX?29WaZ&Ko1B8S203DUM^+>OcME
z96y`F-55#|=KiV1xCV_@Fzt2D<}!4JZzXlBmDJ5hgnQu3<Zd!jHVyk$N&n3U&-uJ{
zeGg%6ri95@fu>SdW&+_{p1L>pd?Zf&rytz_a>(`HEJ_(iYIAT`7I%~xjug6jP=Q>W
zpJC_<-zM^!L;Mw_RsYR{_G-F0Nc1`|E7yN(7`L5>)vgBk^&wmjg!2-ObN#oPoUGZ?
z;kWHS?`*qt)PJVVQjMHVF6zJOJ;FB$|Ene7>W(|sJok8*!L>g0CH=RQSn9viuxN$;
z+d-;z<eZUW5?*(w5TlhD3+~sf{##BC>c2C1HiHqySwN!x+r_g}pq%^l{I>e<RPu^;
zKqdWm2Jsw^&h_6p+?Vv<Sy)RAuC!k$YyduMU`hXN1lFE{tCnnmX0KwjF4untlm0tE
z4(>bAz?-?y;X+1OHx~8ZKCGmxc#>hkwEee_SX;2Qj-qT=`BDF!g?)J;qv`5DeK5}<
zRtxq(_1|&Q?}Hbi{|;k|?n(aqYCC%^^q=!)_0}B$Y!f&}0JC$I+?PgsvMWAWYhouI
zWo&SYr|+!#PmWqA^gvbr*;-KlX^oHlxoU~27sU|Ljpw;vo@hTv!LIdVIPug8o*R)5
zTNHkcrf|6Gml{U>=X^Q!pSw8;qqWX?ZRPsUFR<8&f%?yVlgjm<*81tB58kT(T6y2Q
z{@YG1boUh3p{l3W=lX9kCCy6EssGlI({lI``fm<WuKv@XWhHg#Wb&vZ5A~n(cUE%e
zE>Ls1o5YCmIxy|1|8|1sI%?7`IIjNN+#`RF5OXh9e)Zo4)W?f~ME!RGI%xxR*a6g=
zd8hu{L1}VhFR?E|p45L=lHw#F8Of8aNSynd>@4cP%aO^g@O>w;Hj%N+v&rFXa(4x(
zE0NSA<hPp~&#$2Wj*)*!|LuYT>c68{@(-oDb{Tos@pKL2*6Kg^rg6n=_20Ev!PQ{f
zplvNJh~r%CfFkF?<+GBHsrv6yaH{3aNRC0Qlkct)H&DZ_As690)Fb__2fHQIvg?!n
zyO^03`;z{9ka6`}pvGis=@C4K9|hj?@NnJ4(>ACZ`tK_8eT=kQS#f12^He^B^gYbT
z#6@7Rk@En2gLebZcGBF=xJfIq2N3ry)a+ZJ{!KvZ*Z8I$;j{hs2B=eN|J@9h)(%%I
zzlLAi&Y}NY(Zx_||J~1>D=LNl`(kml;a%{)d;Rw$&mU(5<3`T8{&ThYd${jD+zGv2
z0K31%i&y=33nMc>f_8V{%W*$5%+BQ9ui$^^zvrRL6Xd^-IHCVuO#1I-V!hBo|J|AN
z-($=;dH`&{N=~`{djxv^68-lwym*3HDh1}SeXmFQ`8Az`-1LLu3*pXGAXuIBpZf`n
zK$7ZtQqq5GQ>}I{1V^VDkZkqjDB{|(a4ov|?fP#@QU6VW;`;n7hnv%g*@RwpubH*b
zUj66u(0uV*PDyudX@W|g^}lzIA@!g2Y93TOi@Y}gqx$b8AXopL0_|LzZUfM(|JJAW
z-wNpDYG>-d<w^gYoAjUGoM!SJ25f^U$+pWbXcGEw4LLQDsweoiBdekR?x3Va)QItX
zjchF(KuTtCo$J5bJL$jE!Nd8Hx1#^vf^6K4H`7Jbf>ZI#sKY<zD*U{cQ%ANjUN{d)
zJ_8(W|LsS|sQ=zft$I(P1^BM*MgRSfcrW2|r2hLx(tr0u^GB2ZdnW0>8>lDhzlWIp
zr5xX$^xuon`T?ZjW#&;m%e=49f8S<?r26kZcszg=s?>jKh<%ju1=g(E!7({`N?pl%
zLO*QRe-HOazi%P!HLQd5W$MIZjER1lRNqIBJkQ5a{rA29hrKs})3YiMzMp$C$xN0>
zCi|XD*2%u_BqU^kumnih7YTuc5DXzCprVKah)_YqqM{TKK?E&}s8qpS>xQ+qE)}b_
zrLSA9ZM9nay|#Y+{{M45_dL(6&pqh(eedtro|*f(x3gT^x$bkWbDeWa4>B7s^xyMI
z|2>b_&*$;!sn&lF0cS`3_Ye4J{Sf_k7y72eYDK$&`33NP0e>!MW~u+a1XcTU{nK9b
z-|TD$y8@{HUPL}Z|9uPYp2Qr0McG*9vJJ^{{Wp-g0l&n%M*a62B<i2wq55xj_G{*j
z{TBUq9{&BOrjgB+z%(U$mKkGN_F7hUS^~B=L*0u0Tf`dZ*Flfo_1~+hzgG}%8(R1(
zH1H+RWi3)Xl{pC3-@QoJwW<DIgmk$M=;cV}QI4p;htS`<k*JM~sJ4RTK)xqKfqx4!
zxCfcD{jvw$ZvDL$*_;6u&Y8UmS$qvrW&ORjm->6OoBDejX`V)A?jZkX;84`x+wrD*
zC%WtQRDUmK-sXew`$}rmM)))wue%$8@R3x1-v(Tl;ypDA+#jNrxcAr*=ywoVzCG37
zH}cH(i{sx-r0Ti;F3z?hal_zJ1FP^?>TiE$V0^yxbD)a$%Pr{er-)ZydY(G)5H<Tt
zrSaLfQ~h0>y@z$Yu3!eJ^|zI~d8{ixF^l@UFpK*8(Nuryk%k>;^M%=uN*l8l;2Q-5
zJ;C>zcK-fL;_u%>?PuZdyE^dq?bP4z!{3_|e}9M+{t(~7r;``J_Y!|UmH7MX#NRuq
zRiA^lFXF*9mOB3;SbmZ^{%?uD|HYh>UzPp^SpNgw)Z*{*>=fdU%GA%lDeLF$Aaixr
z!pd+XnNf2WHQ9COPR``-hU{d#&#-M|Ie%NTjd;=xFP)v;$hiN$>^so)Ea)nKzX^XY
zfr?AAe@*;dkbRhZeqI`uos=D>+*a0{lfV12p6Ca8%fXSLXko`y{=D~dT}l(brq9RA
zdQVk(YsyF!w&Q->X%~4Z!B$S#`n@U^v`5B>oK{rr$BqRBwTk87ShnzL@9xKS|8!j}
zt*xklIv;-ud$#tPqCt#fOjoO2%)kk%7R@1#7k&W3Q=ER<?_<QvF)?$9QM^3QT4(Kc
zj>5_XN5O;s#ql?-mNIQqG0#>CXgMnu9J|(v?kHc3u*<*R#;ZH$D+e7VaOQwAU_ROv
ziUsGJI<~FdU7KIPQ5=6I-Zq?eaXBF-jw`;DAom=3>I?rJhZsefmMZ`4YrBhR(Ga6?
zuFa#>(^Yj{g}ylcS_+(9JecpEe&CMy^o9Sf0OYQX)%@>mysk4|+I1a?&;}X&*J{z(
z>#=jH%Ka45IS0e>Ic+LhOJlxqB~EWw&b4u#i|Z%5(z>=9?J_SVh=(grx!QNp;9TK(
zP;W9VAICbHxpJT3qG1&6EN$TZ=nLfhcQmAESVSLx2(6po|7>!ZNIzy)(d4vLwFkN4
z`yA*#8*b_oTfF{P_&+__n=)FLi|FSS4O8fY$^UskvGFDFe-(YXCTu<O-yW&_-;(-w
zMIorftEY$9LLbG|u8RgOEAto;noOI|wSJoEIjnz){9i#WT1NdpsSo_WgjU_A#Qz=C
z|MO|#Po&S=*=x0DY?jiFnn=4i_<s@n*KSsv|0iSJ*aXdYQg0T}l62R?MYP3=hKuNd
z$p0(oQ@k|(x558gXl?JI#Txv-{deO3z3`tlX~7Wuznxb1qu8ZxOS9YG+DHEHrx$Pi
z&-wrUKJfo}`nr$7|D*JjZlI6-8Myfgev5{swDINt-KqXxL=SHRv&f6{|8r&jf0>??
z{C}p8{QrLG2W9?$7w+AM%}f2S-K|(yRr>GEe_QI6o=fy!f^zxOh~cxmUz4Zt+&M+%
zSspuLRB}m)`tV~)+hgYEU*5a0r&K8|zc%BD<yG#7>=W-yoj>z^o?D(e&XKF{YX^Hg
zdCyBIy^j)Xk%v!UloRm+len&iKGNC)GIhWe&_<s2kSci_`}Z4iSjEM1Y{SO0@VSfe
zrob((^%%+H=J?o`3ThOGE_#iYXNi_(?<stW0)n7QCFkI8lpTJS!C!k1_CDj8d3bMb
z@v8)wOVGU-gr*iUdo}h`^<(lJCFb&zpM_pes3=z|hDWAp?Oh79un47G4jOx}@1cK|
z=kub$9<v@;_F<zZtCw1ir%&w**vB?r#1YyYk{q*0VeiwJ(TDd}sC|}~5I%4|Efy?Q
ztn6QjvAnT|8!(B#Wr&5P8e8m*<Go&vri(NY*VOiKj2$)H-dp6Nx02N83x|v1A>=VD
zOkDIZvi#_O`zE~SrLoV%Sv-s@lwL_Yy=;_$q9N8dkP_k?TEg5dTW;C&^*Z{@S^z9b
z{IvxLr_clsLw2>01Wdvf{I=KYonHMxcajtgdiI*iaWE|aLS*Sme!w9|d@5{0E|0<k
zSPw&cy&<J~4GXW&A`g3_mHI3F%%ynm*19_=L8AA%&<UBfK?tJO+UE_g#UaF&3c{Xi
z4k@a2MBIY@!sc2jj{L>1(EH3emtx~}(ID<hik6F5$4oC^*Wa={x$0QE-1lDn5|{|9
z{B@mO>859obneF!AqoAWH<dK>nK85xm|Jo9^sAC8N|D}9QAhPT5Kld)Lblal!Xw05
zRK!V-#`sc&MM3Tw#8s=R9-)D&R)@F>&#U6~!`1X1nK4g&IqeJQ`cH`U2nbzcJpH?b
zOAdv<nEEejrZfuuryWB1)DGmTa&ks0=&hv;8oy`=e`LMTL*nckH<N2fVR+BGYKb0h
z`g%IAR6n@Tf8o0x-rCY!8<%rR>(a0Gs#tSYn~z%5ny**d?_d8}s`8^BsovK5m4*J(
zFD|T4`fH1)^G4k}P0u>_K~yJrCGAFX)<>^s(6?F{clEpQpVb>%-%q`0rRnGdhjJ%%
zLjT$S7{xm!ZX{O~{U?0+3U$KbK8$+j3biYr$DV=KxuQXz$x)<L|7i(zKQq@N4*lm<
z=s$P#)7mkDSmEF699wmdcvzFG^`ChR1e)-LcaK8Xymnn4pBC?54JQY&98bxy7oN3J
z{pX%?9{RZ}je72AL6YL`Wf*NHeSWMf!--*<CLkD#eJeCytQ@cX(w)M`^XrTQuZsrt
zpF0|a{&TNPy_fXA%JttEV2Qa9+6bHR+tFsJw|_IxDjRxRhyIh7?t$i>PijnUnhojR
zeV!)rCuZ7uiU$1-bN%PKdG30qwa$6O<GI(jThBuMu|xm4L!0`~)i2aVYMn7qBvxhD
zBQ^BjB)H&CfBKOMuk?=@AIfgg;9C7tDND<zt4=$fs-L*!kLTWf;M9NmQ-}VOzt#HB
zx$4%;YW?R7=<#3~)XMeWR7x=BIC3i*24L5j1{9(H+=pulPg>xFJ6l%t-#B6o<;ip~
znc6}B3CHM^Cf9#bdpev@|Bd2p1J)<?-)P{|N8HsTf8W8CH}wS6!*vqa%%EH?_v$*=
zcXV#cOrV$rG@<{d^JE&a8-PdsH#^ZzoijG^q!@(rz)@W1l7rsd?pf-Nkm^5I&39i(
zcTyM&)s!)5*GLLwNN;{qjv|#jbe@a*QPz`_D_qXyoa?{IK&ii+`foNl6b(YuN(u9j
zDLn~YC36gv7)?2ofmKg)^`Bn(u9oh;lubZ68@$wiGoaBNVl)s_{pUUagL$?Hc~sLa
zrcPL+tZDizFG^2~>%aL}sB`@{2k2~Hg#Me0tayxvXETsTcXO+!yiweR{?l7ePFM7w
zTo^-+v9G18&Fee42)M_Ri~4T{Df*)ST1c^oa`jx2L#|c11WVp9C@}-*W>J=_&byE2
zQtD0UKmGYyh^zjahJS*qe>D+*A%AnYU&TB9Npt<Tif2vu0!^f>c|hD3{pY*_C88C}
zoV!=5|Bgv8kLP|K6dOVAqkvB7cOBQolr<gR<@#?S_~;33J=L#z2=S)CQT5+)c+!l$
zbrJcl=650daYjMWupDk~B$tZ*TSVE*fO#bFs{a;~Rp>uG(A>9XE>O>>Y**1xQs;o5
zYgPE9fos>{T}Ep4pI+=fn@`M*$e&)*Yx*!gF%N6_G)5G1{kIj&)qk#av>ux2Cq4j<
zkHf=e8Na#ybD!S+q#6LP^gDB1RpTy)TE_sv@nE6;TLYBy@xjr{F7)5=l<@o4e`|nZ
z8e<b9@Il`STqgtXB50|ub4Sfw|LuTU`sNQ{6hi%XD)&=>t%<8>|E(kT>Z0t$b7&<r
zS<0A%`cDt-@uf|0JM^FHbm?=t01D^&Z!yw#Do@mZCz5h5@izm-08$UYBj`kAL;bgw
zJm=tdw1K}>Q1K+ZUPAxv0;{57J2|zI^ZC?;Q^;u$5FbxY+n~x0U_F!Zl?J$W5>H<S
z=ITFpLOq-E)qncup9?)!BVVEa)^K)j#r4G4f<=52_~rWVBs|1?y1poQ$i_Z+c07;_
zz!Pf_v<dxp4A87h#|}n&&OtMr2$c1V=7j#+OgXzKWgG9@KVTcNO%wXh)i+j<oBHou
zU_AzTI1hYJCiXUdHx`EPTy%o^Z!6~kjKZk@E@wR91UPa*(tmj9KqvLz0m`cAzjGP+
zQU9F>WE&a1*+vfg_?v@I*CFybn;dq+osImuR>?MKd<JEy|Mc!G7A8}}a{YHLqZ|E6
z8~Se(@)P>+R3Hfbw+EQdWG+Gze5&Zb1Ne%m|K#R+u-H!BKObDwe^({_cMaoL>c1;^
zyNx)9iUCKgT>o7N<tHG4W5Mte#?LDH?<!(tP~#%XT1-tCMH%yeaWJ$}|5*!W^Lzn(
z+Xvk*L;sys)_=QzB=q0QiJ9xaS3!rOA@twvNU%Qn7r^H!VA+BXs`^jA>sLaD(0{Kk
zUCg^l_{g2ic+@=P={(+z$H(|aB)A0$RsWrf7g`%$Wpk<JJK@g0vi>`QblU#A6AXU;
z`tLUM-_<}c0)Nl9mi6Ba(DGc$x*y8C3~gik?|%5Ogj#eq<5`!Z{~qA}5FX&6|8^1k
zjd<hsP5-?b3Oqp$ZH#Xn0*X!eM;?HGHvrFJBwIhm(0}^N-%8DNhtY#c|NQ}UdIzwm
z|L)^B1AoKNe{UhrIe0y8U|)kfsVfiR&3z;A9iZO#MgP4b>A&Za{<|Ok{Ylb)kC1z=
z|MoLF*irvI1%2L$JT~H;`!p+j-^1VQkxAQs?<niP`-l<x?=k3oJvDs<tNDBqz4UOO
z_1}|Vc8EQO)qhtb--pQK^YF^!8Adxlh5pkE`5->b*P};XO-b)gdwD#;yGQwZf|#b!
z*L5ipb_Y2fY1e-bgU4sc=|jYRg5O7rRu6m;@21A;VIBHUtY7G&|6Y~!pPq}&$j>Mw
zeif4U&7}XnjQ8nN=)Y&m`tKb{|J?_L-$ea*1G4!U@U7^-d;6&WJ^)2#BYUmj{?BFo
z_aR{ZC|cr!)Y3<(hby7S`=Hu)7!5uXKi1HHcR}eo<nhIJ{r7GBXJ17B-OoDhx&FHe
zoYa4B0t@xuCy4W-!u0zPvTOU#`3V*M_peCP-AKwE)Q5i|uN(0tSN}c52zThef5eYh
z{r8@B{pZSCKScli2&lh>{(BZ#{5lvng28*4@u2>@H?{x%NB>3p?|<}P30eL>TmLzZ
zkpI~Zh(D`Wmg<<laaDabR<Yn1ik3Fxdp7tauH&3vr<W;i4o9RjkDh`f8u_33<Rh<M
zo62$VDBE!e%l1A-0KLu+E(?Z$-rO9+FbJii8<traKMn|l%`t_ZLX7pAgYhc#(YhLA
z+%fv=XkOrH8Tp^rmM<3F2kl<Icf2ab)`Z;gEA#M4z-{h66)Q*Kf@(2lX%0Pwoc5j_
z8PuX~-j?VXrz1Iz*2MTjPX8F`v6P^H&-8J`$ow1?jZqKjA^%M6TXS~I#Z_){OoiKP
zZEf1J`!XVEY{v~8(Go845tFdqI({H610yY0wtstuKWJ+C!XpN;XLLw~IoXy9zwCh3
z(M9d;j-N>P7^mf;+fYwyC?C}pLW8t$MJ_G#o;~bK2)m=Bj?8&Dsu7gxxjiT4^-eHX
zVHF>Fq4iyfQeNDdI%uVpSlhAVZSq5T5FgWbA3{DI#SHljUu{RI98t^V)7={*&&b_X
z7o?3ND(28L{PHoz%Y@t>w4*CAo)Dwi%DXWf(Th=w7!}oeq9tB?W6$+V+n@NlGKDKt
zgrByfp0O^G)^(u``4>AmD(#%R9rtphr=Yy}-f;^@2A%&C>s2_G6=P@eHsoLG#7Y^C
zmWpl2RB?ZCEt=Y*Y)!l7h2s&9q$&T}R2=nGsw(pD2%bLe-3M3hSL$QT+4XFde|NQV
z48+k$SCn-uPKr2IqP)1fg(F3dIap%P^*5LQk-#~Wyc|7t2V+-=8A$s(R@QMn8^=<D
zX1V;k7e+I0Tp_Ec;D}eOyXA<TV}QB*TZZYi=ej!2aI#ST9sTM@uQcS}(Ue;9FI3ve
z9Jh3Jok6Le>KevA(c9lOs+51{!Mc~1YkVkKwdLP60w$5u81m9K;=ant|3sdQ<<Fgs
z^fA}Y@17QpVJl6JMk@bfQrY6xeF*t?T+}_T9Ba{AUio*&u}S2o$GS7bWBhpp*YagF
zrA;Ak?;Wx0DU1gm*Vmaro<p$oh5S!}3&Bg*K5-mF3b_)G`+>CpgL73Kaa8`DRa`uT
z{I>vEE4gUx8cf^XH9>~cTbNAV%D)mj0V+Cr+PnO_(t&$-Oee)mdem}oev*Gz1({9%
zdoaBu=N44Uzayosq;YJliS#`Mv21}F?p~$*Yh`Gp-{Lw=t_?Gn^4!CB3V67(O6dRT
z;4_G)A^)>T(Nma`QnipWmw(}$Oo^^hu@LSKr@!lpEc402HH{qom`snWkus&zjGFR4
zA6w5%U|9mb%Sh#3%NZqVKOO)s%Ks`#(<(cgzGTS%{3I81DYG~I?>Z*y$axGoEB~{&
zn?*Tm>7S1!FXev;IW56<G!DCq@;{gIR)9e(e6hp{l-N_q<$pPRI2OE>|Fysz^6$D7
z?$4|I&xYrXK+ysZTqW8SqUUh$&TqZRzcbwH>36#3_3`8v`w6>0tLx%SA|K^{0j00w
z?l_JXcrdQC35=9~?a9aY1b#QqbNOF~MK0ujId((ke{EU*msiRE#w7ne&&Ozn$|3)!
z!q1uX{#OCjIXrXBLiu-vm9r@+<o{SG(;wL7O)HiIZN`qY^c0-MFTNwm^H}UbA^#VW
zVhq*|<$oPk!ZGBO%l~S4yNhET<!_;+0YKn<{qDoAvix7bc`bIO<AKvvfVAjN#j4_1
z$3E<AGqByR0Jo6;ok{+8fys8>xUN=Dp$@1oP4e&Tj`Oi_<nq6}UH-Sj#Y1KJzX(gs
ziCF2@kV?7OljMI>PuU{_A^*FOv{RD&zk)Q55*$u6-kjwBT*_VyZ`>2bRYtb*b~z=?
zgHo5kou1|YWVkmNc#e|t2Iz7E99xThD&+rq<n?fp|6OJIKa%ACmDq~b0LA6l$TndY
zI<rUk-EVplkiQuSUxh8_oNncR9~PoxS+`sH-%GAbu@o!+dy@R$0#3!l9<Xfy>Nh6&
z-wXeiV;QZ-rneRg(UsKi<w#7f|KFVC{|!B6e>rI`fG&fPz&9lMzZ3a?if3=Z_N)9q
z0iB=hApg#|8H>H^b=Z|2!K(Nc()Sdq<^KWX`Bhl9E@vd?wb&h=CYL|JCiN`x|74Q?
zTa)ftfn9C|&)-YlwdDUfa%zQV7jRySHLRoje;J$baOOcj-7f#`<hzWTr~ZEqYJGq=
z@9tIppX?(4Z-@3*Q=c9H7xn)~ll;FK&cA`xApQn?LjLc7>mmOi=!ra7A7_K@66E;(
z*mwVsn)c6FA^!?oegbu#U|hrb`hUS3mq%HX{we0Af07cm@^(41)E{E5{a^Pg|6ggB
z|F5ujqw@b%;QJZ!{}!b6dgS)!N&dgyF8>e0gMUx*|9wjN*Z-0K|D)w!>w|yM->jUy
zDiVwr79(@;FSqh|RXf<TjPi5)kX9_87D=7wA9kYf;SU__^_o+yV7v<a+Kh7e?T6M5
z+6VM>jGla0;I!XF-@bNwEiB?6aA*~?_mW$JYNrps?C62n{<6nyZ_?gbaSB>~`21>X
zF}Lvft6hHB2`$m`^mG*>ZEZdGX{&S9iX+taV}!zT!}ev*w{{5YmlhiR(S!c6-nKr)
zwS#sI?G5@*hW*N3p?yT3)DB9yEd)!Gcjgpl?K`!DmIG}8!GHb9^^cVQ`VZF*!GC?b
zh1<5RRuQcn_T!2MVU_>x0xkcwheY4CRt{R0!k;*H2GZYC{_E3Qr2OE&`+aJ8(5E%$
zzb)(9A^1PG%zwRSwNbdPaxwl(FL$|_m{MxFiJd_8mo3JBSKbc(yOXFsvi2n=^0Wy5
z8i*PE*MC<2JBwfbPwA!CRH2Lfch<eD5a>gvU#8w|&Zh6VRaHqJSHXY#%afph{MWuP
zyK}T|?q?+a+jG^6a1iN+K|%R%o3M5mL@!=Xz6G?!^}lZBF6#dr+PAes3zTZ0O*S2R
z&m@ml;O;B`7n62%;{Q}~TAq42<LOxy=l|R!ZA)o&2LC;;0jAoaHSvFLvJbeIch3J-
z_`jlda@vggU2cWy8_WDZj`rA0+G$(pD-;dOq5nd97$eDPL$Z2o;_B1_$xnkzOX%Nh
zuHyd|p4o>i;^iU#^?JIHzG3kHba<dg%(;d6e@x>4sbKBulaorDkiTQ0hHJ~!3MV3^
z`^)@aN1Zu<7seqZe<v;PZM72fK10)<jjU{k0`mVH;I2>SV*GbKEd6lzLi^2C{NE4%
zuPIQz-d=kc=Rb#0dOfdZ&?9nPw-adh7w7-YwB#4kp1%~|o;PuIF*JN@pZI?-{imq^
z`|%^`3;%B{^Zz-#q4rY$<^N^y|D*IRYKPmX{SUYE{|lsfJ$;>*7v}%7tg^PB{+RXO
zbpsC2EBZcOL7!po#%F3556pj1=KphefIOb~e?8}~QU6^VtycIk)VdM={{VlD&qDb-
zSb0qSzn|XW|M0&S_3}PPC0@p5^e6IXap&{ssdRkr+q|b@d%0_R)A=RO58IfLn{V>m
zY`>YmeFneDdGLvUwu>FdHJ2zOVpw{-wf!7@4oC9xU`yH&Slji{w$J-Zc?{3ys^7SW
zE#XRf+vL%oig~v&qE>lttK09b?J(hUMq)Mm<{51)$3SyhRnptqat@L$SXXe0F}Vr^
zj@H@2bqrBEw&S3-PxBniQ~b>(W{^3an7<Wr@z)Bk#m&A=clbL#=h#^H_&ajx*nzDQ
z$LFf^5BwcJa?a0C+Ahu=s+6z4ulvxu&Xlm~(N&$^*@hE{VLEqN>5Tt)QsnsCwj2vS
z&K}B3a9quj#ouuvXI53`-;Wd%Xh{s`-HbB+BimDxQEDYt<L_*kJa_kKurD*SjK6EA
z4<et+dsmQm2a#(0^VROn-QA4?|Ha@xk@U`Tsibe_$*P3EtJRMs{)`S182HDI6Qi*z
zJ43{FO`e1Juf(D@gf_qg-fTegSLdJOuRVGO-(}ZuU)`Qs2uE@BjQ>{fUClQo_`fSb
zTaEvzW&Dqa3!8~`0<<`#D*wR$7{2d|f$cQfDIM|OPL7Al_;2I=ZY+t_HE=whpM&|X
zoPhM@_#f_o|4wXWM<_GL|1cKjoI1+?Zs>9aG`bM{4`GMC3cG3Lec*o)IbO=4{2#2!
zy@X}=626I#f!WK+OZ@NTi&shiB>3;4{PzNdD@LEd_2X6V-;C9JBwyGMfd3<<k6>eb
zeFy$*$6xgj9?AM$KZEyYXZ+s+{x^5P|BtXeSMxvc|FbgwpTM5@)vEIU|HeP3l;^n4
zpYWhi$Wv-%iabJ#7Rx8TD%zyNE|vfKttk@1K4Z)%J?v^;cm9rbpPRk=fLbl>mHOB3
zRDAKePgQvub`8hI#UQ+}OzoWz<W#Ms=y>I~!tatcsqo6MbS*paE$tY)>z(jwRSI~8
zM*oKR78kKm`Q?qTve^3t^DI<;nQB{@^s)&XhhGol$M-dS)oP~?`dgmgK}*&)pwE-I
z)K0H&l=cOo_1mP4FsR_STHf{^{BBo#d+b@e@`C<LVJ)l8Kj-?(f30j%OnaYe5NN3}
z^j;6b!^dy7-bYg36*9%!Hbd=TY+EK;({jl5m~tfqchssC^w@FbgQ!39-%=efG>_W!
zcmDWjzEOI=*jIEWxfU`lb^g{0wpn7nv@L+(zjh{P#P<WXTEX^?v;U0iDwTePT(3Z`
zj3bX)L2n#=h?E;43I6N9(46wB#XonObB>z)p9lu>e=O9H|5Bn>`r!Wra?$%n{yP`U
z7L;B+wS#K~IM=s@U)Rc1a@_~RJ)Mg2e|DMwmO0@i@_!x}&!gnl#Q$08su=%man0oW
zsmv{al2f7Ld~lfy_Wj7SR&ei~iL|NY|1$VLneTY;e?}qx>y5G?@qZ@g;C~A(K0Pv~
z!q-~-8-xGCDr{=~XuV7X0{2A^{?7-J+Wc>Y;*RidfO{LDg)QMp<f#8rky(Ixzc^z>
z{%>yQ|59u_YZ5(b(QhrKFGz68|IKCoujP6r?aD>9k^}8Z>@cqXes<#eYM#jdGdM5g
zs1<_$r-8+AT7cUV|1SWS^Ai8huaz7sRrr4y{NG7CG5CKDZO)$kLh_7P;*HUn|L4-;
zE6)E{CjM`vWjK*^7bpIoM*WxnCsR!C`akFYYvKQE8Tr2i4CMdCV0L{DWH0BDcnn;G
zmFDs?|IY-UOOS_cr8f9~S}!T%)gQory*x_Tq)LphpGzGmF}mJ2{yz!-p9Is_Av5y-
zJoaT7j-BoR`SczpvL@zC#_gBjF%bNJ4Ld))f-!jO|8u=3=50s*Uq!mFl==TD<{3R$
zGyO_ZIB)JKP}~P4j&gh{@&7(#@fOne&c8dEfAl2Sex#lM@1p*HG4cP=0{nlJ8uwo6
z|8KE}$^XB{E_WaN|2r`IPk2}>{I}u%hq6-Jtz};P8C1zdgAIt<uIz<M50LH=j&G6n
z+noQH^Sg*YgY#pg{V3O-ALeXz{W;eca2zO?#iOnv<7Mh8jGZ=f_S~-TtDby`sDDJc
z_i_FT=Rf0k7uSEz@ouia#_<r>f64J4uD{Otn;egF{TS!>bAEy29FA827e?1M6~jk3
ze!%t1%I`eiRK6D%@i6`r@(@?=#c4u0{!Y#qfKy(t<(hcr#bzcEmonNe<(YYU_VC$_
z@hp}78sdMSXXSF*&f?nR+&EIX<d@RkKsw4dzfv3LnlvWf|0^N2%3+{q`ACbKU;0h`
zcve?u=QZOluIl>HJ@DO#k)y|q8$V&<q{&mJwoIQft94EpxKEMzZQ%1cj<<9DdCp(p
zcqhk~Ifn3TIL8a14b4mM;Mr)7Eu@zh+js^I6Fq%?GKU5P`S4*5WHrgAab8VaWf#6H
zv&LyVk;62ml@IdOa>{%rR>6=Z!axu3r!Ozo(x_iuzl>wxkfx!-nups&?-1HPLRoL7
z%ujH9n(NPUej|rC{2^yyyPM}v1KS5Vz}I)_`C6_w@($W08c3(N^G+F;Zqn>koUQL)
z=XfR8#A(~bbst0GHmHdo0p!3g>o=frQ17F-ZGQm_pW*l`l752o3XVVJK*lvmwY{&{
zb?@K`4AAuJS6|;Bn5rVTeHfTO&hZD}eHRB(nrH~^65XJUwCeDDdsPNrBGv>%IqT9P
zZ2KzjzeOG&<NUe6CE@fIuEnjpv(5GDP*+!9KVU#ZL%**1m;MCUo&#3-`X;V(o|kzl
z+@(g2oX6J?=h||7<e<A?eT9Yn5@H%ndJA8p+;4Eex6-G}_}t&kIp?SN`o4VMHERk_
zrS~Tc7*JQM{AY=O2M0JNSx1gj-6-Ez$ub<G($#k=(fFU_nX)Ea9?D>TUExJtecgbD
z`p)T}pxh@Z{{x(#=6o~fy`+CV*KgqZBCdbKaRp`k7ss!;ew_1@oS)*nk@F_bn>kCH
z+c;WD`zFrI%jtc#kZa%b&iwQD={x;to}2#{%I}TqL3+zGjxbn$g2(iq<{*BT^jDFF
z`1$+x_*awP5e{J~<0Cu?AIcJ*l)vyDPaK-Ysr+r6PbnWfD;khN^#~cKs+*JwRhZ94
z9fl)=(%CQmlQGh`-2`xK`y$W3%=vi^zsd8t=lh=8Cas*eaKD7(R1TZw9O)VNZOz<|
z<E$JQhxqBedF1b_<J(p;K6$p$ytVDrb{z-lJKX!M{66KE-{<8Cllga(z8XH^5ua2B
z`Q>@#__U|5f=BogjFwM%>1g8FFpl0r;s<=G<IlR3)Vw_58(!ZJX4Dhv>aDqTb*c8E
zwfOH>&wmdYUq$(cd3S{KQO*ZA=5eh&ALKl!e19U>9^7|$R^WYi@lzS){MxUp?%SXB
zP+s->_Um5YYmd_nyuR!3egO9z316hTt$g^b$6$R)A0fYS_5B+L^dHdJFrabZz=nZ?
z2JsahGI(%P(~u!Uhc*pu9yV;)@ZrtPBSsD%F>)0DrHp^L*j<=ReO7n;Cvg0hV;c9i
zQ<a_1@cev^ZCtA_ALP1d0H+b7$Bv&kt@i|NKjHm9k@pA^{F3vpxL1cx1de~_`hRn6
z8@z=B{g(71IwQ4>X^*tc<nSAK7w=|sJ&^069O_%-Eq#Y*%cXnu6S&|CQ^KVq^yvqQ
zBfekcxRYmJ=By5R9mn(Be~q(s^shL+!~K(-U%{F7r0uNIr#Y){KgZcR&XL-jf6Mv9
z953>Wyl|y2wf#Nk|IY$A8_K8lbN<BV^^JpVl#U!VuG}o2IV+{9{&^E{`yKdW&i8PB
zCui{%xBEE6>%E-SQ_}Yw&d@aJQLZtsxTIas^Cr&f0H4Eyw*8!ohx*j8Hom&147+v6
zZ*0Zbmm|zGLfbH8;-9(rIoH47pq*bD%d>GDe(P@M;QN)@#eTO(@m}~Y<vHyJzu~F9
ziVjPCvpu{+Z>P57cX{?b4&~u#4%&gzDYez^;Vi98C(hF9GLGL@D5L3DvHt*cz>uaf
z6S~X$F&^Fx3~%N9b`IqioD#g-xqctl>Sl1y`IqqL9p=RN&db*uIbP5GEu3%Q3|@&w
z%076tE#ka{<E4c<lJT{v=d)AEpo~}LL3dX_rR;y?u)i}Hp4txo1jln6;GWvx%IC#g
ze}m&Mxc)k4=}|jmd<A<ANoU+elt;+(Va_?tHgS*MU^qU8+<mT|Q9rzf^B&H<hE#CP
z^0m1n`Q6NUDH&SVs?XL9-gO9m;W^T?AMpEQj{eYY0LM*Sn`SM?dXAms=XdV{jw?8*
zv+3LYXPn={`v?%95Wn%H{M%l~_<p3m_e9P!Ii_$-BM)Jvtm<=Wzg^3-i+C3SX!-8t
zchzV0Ikd&(7x@sWZ4yTl_oFN4RAzoZFygmWG9-H%H#tpsorks`a%KNYTD+b^x=5do
zkoQM9c5!_sXL*kdBv{}H3!X(={HvUigQV-IhlY+V*=~py(c+iyRNI4GN-OY6beqX_
znQn=8n|OYJXYz;VZQe^$&dH|X{XC9~IS7{Tk-D@M8pO*^zqa)g?$8dSY@%y|Lm1}p
zOqvQ;`Chsw`ulDnhj7Rb%aQJcDBB(=E&lr4ZW8Z0|MG3UlyCMq=%$UOlaWFe*5r35
z$2rL6HjbUtB^OmZr|kkT-rPmnQ<gSuQ}=>tKi~}z<&u`SEp5{se`0A^`*~Jd`b*E)
z@QpiS_>30xuq0U>!1TLB6GRcUaa@;L#CeQXQaPAk=&vpFFHc%Nn=h)caUhMnWJF3W
zy1Me)liN<AFS3@u?QI+27MrxSZE8CaN?0@6(QMCjA)0z(+a!20jlX&6cUs&0wyBAm
z#D`ARjd=!V;T_v-(2Hn4e3m$BY;<<2Iho&|jDoTOO^x*f8pjSFH)!cG$8Opp96g4V
zAQfv$?uOJ2sH-13s9{K5!+@a!`}J#XXd2W|KXOFVn4yD*4H-75Vc>{?!$%AqHhTQH
z@#97hA2VXe$PwemELgaB$+G1uR<2sTX6?H58#W%dxm=<M@!zlC&>>mB{{0#TH#ap5
zY_1<QYWRr8!J`I`9W#35pfRJz%$VIeXYRcDe#JTl35U8IlGWD_qHxnUHZ}pk&=I4@
zPi~psrOAX`4;j+jJbLt)F=K804#)-#vTZ(m_=pjsMopT^cWy|t)=)KI3Tk6*7ic*9
zR`#hH1~xV{4jM?ie(=D-Lx%8mAKKJ3Y}nAD&CSD_M+_f6eB?-S8$EK==rR0{9moIp
z@n)959aPtUKz&nF3ue~2i=&L5e^UxcuO*j1KMnl`4an*nsVMy$hV<uWP=EUu4TA<Z
z^&i-O$e^ad4T$34p(DnOx8XQ#`s{i07c5+~Wa+Zyoy$qNgI--@){qSt*uSCwpaBCL
z2M-=Rq+xJFlRcKEfnYIq+=PiURT%;T4H_C61`?@>)@hd<p;bS`i*C=5!MFmdxD(MD
z8tDxUhEz+JmjGnV+R}*!5ANH)=U~gOmRWlTMLvrbEk3yS@TI%=?>n^nvI7VA9bJ6M
zq0^6Cb?M?mM^4##`j*{sw|nymOLw0?Ywzw|vySdQ?(B1yExMF-IJfLMbm*#US}r}Z
zZ_hRRT1qnx9J=)2wR`uqtUr3q-UElOS#<fa_)fMzJaFZeJUnvXP<sA~s}AgK>Aj3O
zL|?P}nt3e&!{%!*ThQgnu6;)rw6x@p4<0<igO<51uNhR@bIDalt~qdM|ALkSU9m2e
zTFPPf?kktATy<bx%i%Jr6mv|=pkCioMh{T}fF52RiDZixw@Bc9M~}AbKXTQzhg)8G
z;F`-@mbGj-^=P@=Do_%X8(QY%V9srs-A)bPT`+6!%Z`ziTvsKN3WOdK#@qI!Nf3;l
zhr_!8mBh0<=GY-Y9@q2X-DSdeEU)~q0;2_0r@QQ`BP}wy<-mp|#~fHcYws}!=Fd;e
z>lkld4$$r^W!CPa*IsgT_rAji*398el(L{2djM^j-*Vt(bD>OidBg#+`SZIzj!e><
z*A6Om&!Od29LjU;KEoWSlwbFmtte;K{o9qjzFpPp+tt0kUDNB^wdJ?)se8bdF3Dr`
z@P28H_qmw&lz&d-p5Etl>*;+?xt`wVwCm}8PQ9Mq=k)98eLDrar_Zt)^jlVge#>gm
zZ~d~IfIXC7gMQ0u&~I4{`Yo$LzhyP(x2y*JmbcR{DXkuUY>Bl^=Xf8-FNlO4taL2L
zc^sGf1@08=gJ~1^tB9}7EN^0t%=(XL#JWqnoJi3?FQ>KzUz#$hVer8E#vzRjG)e{!
zY8W)AsiAT35E?BJYsg?e#$?7Y9D!e2BD|!jAMg8PNA4zQ*(6@$paG)>QfR5M!Cx99
zb#-IL4(i{3XhRcU{N{l}hBl|MvPLp*(g<o>ApHTeCD6^GwNc+M<7p?%Q%i7QMjNov
zm|3USKI3V>(cQm@*LeHTZ=!{S>Cwh&<WZFZGiF`ZKOVHdFQ@g?k2Yu;My+~Q^V0q%
zt@$+0LZ3MGskK#U<M=iAj>$N#b2G;i-J(^qh~6TkK3y|0S~={`*`Ixe>n}vAHi}F(
zc>18p-Vu-UU-~2T$>^cchufKYX?seSCYxy<qt`Q~r=D5cEc&*zFDY#ReJWwe12Cn2
z_fFnwr_e@m6USRP?3dG5PvfIM;EbK4&%yd)YaQWA{cG(K;(9Ijw{d9Os0wY?NBY6Z
z=Ad07^~9<obi8C)rM3;J*S3Ye?eX;EPJ~vcbc|GWXYXxlX&U{td00y9&)K`SZ|0(M
zodQDIYv>fc%kArGgkCc*@UlyReSA;@yqd2=8dNoDkdfb*ccAx%1`8|&_~dH1h*@9u
zl8h7a`=@K$qxuay*JdccvHw%Vk2wIYS)fOFC4THd;$92J*Kk^2nwsLMNJkO3RGQXJ
z{L^_puC$lmO(jGfKTG2;D9z&c#AI+;R}!Af(%X5=Y%)H^I^utW-^odXEhwGEb;N&v
zivMd?@DA;1oXfbrqhuBT2WH!pO82KHr({0q7{p68=(+o=^rFWfXT4Nt>Qy|E#>Im3
z4=kTbmqNGz#IxEtI8VZvmB!bL-Ey5t(m&-{JAEEQE>s6+V-^XP=xV#pHBnY#l@sS;
zIuE3Fa5Wg$v2}K&kh{{YD{eXmLOG}%V&;Q$2=uvkrlvDLlzL&S735e){>zVeRwTWc
zJHyjd))?=7lGnpp<vX8Myq&{h?Q#~3^KsnIp)*gq%gYs3UEfxSW1U=Qqd40#>TGvu
zs-LMD)DxY{avnmF;QBJ|Tj<PFXR+$_@7^T+xEfX<gHdJvyH05E-`O9*|FH$qyN^~q
z*t#C7`^~wUXy5oBwME*?KPfLY<zYjC@^i_T|IS1S{+lwN|J8dYgP@zTF8`%h@P8Q8
zE6RWOca;7aG;rlRdFf7pV|Y?K1pg;OwT_{#G^68#9`5A7`_|1a^WWJI^~~NV%Kt?)
zOsxOzBv)5z;d&vEPfavg+C!Puj~6okqMnA0>w%6d&By0`6%?3DuI@5dJ4h|HhIDsF
zI@c<elj@P;{8!dZ<vc9&8cD&f6jVFN{}%Y=etO1t&&hGnK8)_Q)6XGA@P9J=Ur5T}
zzbn>EuAMx6aZ99h-OcJyod2s6|97z>#d>D2oKe~WKh8?CaE__Yu!rkQn6o<w9_~o|
zKeLMe>q^D>@7j)s8OGWV|BsaUe}Y3;HG}(Rx&NfQWKJUGWaQVCft?LsjQ^97*5Neg
z>q^t%TF(D*<WYqG%kcegp?i_@|2WpA*_8OdsMOV%-xZyU>5^=r?Cn5)2Hd;=xR0gm
ziy7oE#{cc4?a2S_6jPM{7cl#}4chNwa6ae%h4BAYXi}X257Sn=gEDje-%4G4NcV%9
z;gMATzmGe>PiQ6XXN?p2|8DAkU-|FM|D6Bp68~FkmM)!kluj%2e^=ta>)*PLb5Z`k
zG4X#N+!{t}SN`8sI!aDA=%!FJ{6*sb5mu9V6D~aR|2kYG-q<JpzX1OqqyF8MoRFd`
zD*x}QS$c``HfBq*mTXt)`0QsmLRtTZWWj%1<h8>1((zz!{d3jRp#Nr8l(qg9rT<gR
z9l8}x1pVK}`nN}M+bKr>ub1X!EzG*9(EkUeCD~DSf+|M;@fZ>AXNRq~0sr?{E9ZW8
zy80~ezm4lhYa!43&z739fd8`{;9rydbs_y>5qa+=zl!#3<=5xc@8Y`hzH|CYo;}B@
zepAWca$ZWv`%0#__2s=s-k*vm(N>Rlacx<V*7k3-+Vhk`7<mMK@te~j^3K!eaOY>A
z7Ynxfb4a7Sz##ep&S9?ff?ToFzliUf=($A>_So%l<S<A1#)_Ur^v5m3bWuv4yD5W4
z#h|XlGB5MA?`R*ud@8FLRNAn%hwaf>vhnPrL<--CXF%ke{K}S4SS6wip^Phgt-@<M
zdySTAuEy_s@H<_dGI~D2OW$=4!4X#->Kdee;1IFA6E}kxyE=huc`9oW@?4CS$1J}p
zaI(MQY7Oq}Vy^Zfq^K)Ax*~<Vk<PJuO;9v;PM7M@dJmojhul%e99_*QR#Xz3*f%Ct
zR**aP&!xEK$&pwMwP>He8ZEhJ>fo!Gn4@RQ6@IU6O>1HDt*b@Y=lAK51c7~Bp%Q2D
zbrmJoX>tXGSk=k1>BY%ES8TG!@9GE2l(dW0AF5$1axIlz(^UHQ=j`gHmhGBGuDa?f
zpT6^nvFcL`&;GR-*?YI0C}#G=trf0IDju%e=qjDsA(VG_7LZDfJk>g8eOGFwh*Dtx
z-{*Y~N~QFRJf)+$F7!$0n~+T<HngBmBTmHfO`e`hg3tZU<AsJXR$Q6dEB}m_$K~QB
zgs8ot&6Ij!@tO3D9<_BZYKB+xA!>=&2JgZa7Egpu`7@PN7xU0kp~E8Ypqu4-<+Hv9
z`6dKWCj%Ba?`kMQY0WT*jcZJJ7|WG5v{Xf0WzSl!%`NO`LL9x)(EnP+tT9Ty@-AIm
z?Ls<Ox{?~DbK8fY%v!I)@)oP7X^T^CmGQ8_S=(Gy#MsKQFa*RxD~{4nO2n$Tab+zL
z>s%ix`PM7zb=a(|DdME<$6Sry_t07YYlE_0sU4d+LQ7Wijaue<9}%kGYdH)#sK`Rd
zhWt?4L;s6MgwX$CY0qPpUlllMH`ChVdL^!D?2gB=4vG7wyI!tVJ#7@OAM9R2mK^J;
z4a3?Mc24a-q5qB5K#rmRN0M$Zce(y|wG{Q(NXpZ~*TlWnv(W#&?W5EaDzVGdXmT*e
zYW=Ua%k{tOujTrGEZ6mEjSR7<<0{wx%|K%=jZi@y>`Kw26K0-G@9s*tF!F8`_l{PK
z2e;uoA3%?56xV$X<DpxujqDCf>VJ1avV7Ma7FJiZX-H4h|0C(GShhW8ht(?je<Cqm
z1!odH57(R<!=F1TO@LeW2;I5KmF*gN>e@PT%DSumA4S}8-06tg*I<nlZ@;0|M(dzC
zd#!d+dVC*WA@yR^N#(`2N_Diy%*iX|-#j8`wNS*e1a*-73SDe%Q2xz7^5UXT!90~=
z&uTNjvr0hdI<<^#0bx*A3bUhGY8*MF1`TZ*Z`AE-Shb|zZ})`rEX3+I;f%J2t(F)U
zi+$rl2NWA|5aK+z{!y%_9xVmADNU3jS736NIC<>8MAold|6A|fbt^2k*4QQ_-TFBk
zETw|_Mk$H<={{@Laq&=BXm7Os{;vApHHkCiJlFr@$ag}rUa0@a0*|4AXQBT`P!rTr
z%Ct7>(ZFSWma+qZa5T~_e05wY`>yMwc5pX0^}jomh5m2mtkr*HD!Y!_WQvy(bR4Z7
zD;Q3m75(pybd@lIOUEghAP=+=tjBo>{Xd4=ivAy6e%T)g-5G8I5KpFz5&UVfHK_lk
zO<zN`{%?h{^PxfL{}#?Ouqn=<gaQ2K`hObynnNu2Qd9p=qvUbK?Vq?fhhL>>3J{G0
z#u>bK1#K-W<4LFfpTYB)P~Y-G|I6J*o);VQtH#lFwcTUSJ;yuh|5lz=>;Kun-9oub
zk%cMzE@aeq2pTW+{{*g@d224Y{&&^!(b)F;GrHhDNUrlV3ETc$=rM}>QN&&jUh{e0
z0=A2i6jno5`#SXheA2JLb}aozlE1rwWvpeh5?BXQcIba&ssCNgb1mZx6Tu_&|5PAa
zOU$Lfv<~@Ljf|}z?RcP{0CY2W)4&_`|7@P(_Q2DrU{(T$Iizy*;-%?-`$5(|TaRjy
z*r7lzZHr2+G?e#wKT3V5zEzj1QEd&lmt(9>8~WeAmMvJ<h4Y;&>lsUJW=q8HuOlVO
z{4ipgw>rXDeGQ@i)j#eG5&GY9+|N+m=l+L&fz`7kfy6afL;sHj6W5+on+)K+Z$kgO
z*Fs1AZ(UVS38$@$0o=R)f|@~1rFJsBRQ>O0liz>$cO1l(`hO~S(~;Nda99051qhXP
zS9fzS$JxXgN!@hKGA3{E)@OrKZJj`B_or0<k3;I}d1swf6HFvWZN=*UX}nQ}9KC2r
z`6e{_@UxQKGvs|bWltxMT>q~E8}<Ke;4LA)t0-YE&qg50b2-%i3rR7W+ELN}3wW~<
znOFZWC4K1sr9df#XM$a|{&#I&sSxe|)hR_EKrcs~$*5DQ!&rkWmzB^4@^l4|E-c5?
zp-GLsCEXtjO(S&H|1*JhCNR$|zt6S$T(E7Wv}3`rqW>-3sY0#LNJp-|h0y;S(l_%A
zWZ)duEL#ud7MD)pto}a@_p1T?9t)pr|A+o}_5INQJCN$F#8v+<LzirUi^Euzb|t*5
z=>L^Ktp1m;rzKfhgsr}bd)pVs!`()n|1SFfLU>-?{=a~`(Esb8`bltF{eLc8&h`Jr
zrA<iJ$?(n*YxV!RKp6UeBhTDN?ZnbWU^bgcRO<h|#CjQj>i_dOE<|#7qD}WQax{*0
z&#d2l3*#AaamB$F#;}%A+J2}o7bigV|IwuXPw1fkPlJw!pxCug?i^s)3U?Y91sT8-
z_5bOmS9GKQck^Zo`u{Yf=MqN8_TzqckW|OPx4r!RF8W`cBHs2O+!Lja-)R4<|6Q@$
zwV~agR!f(?%w{kS{qI{fySuL13vpjpJt!*r-|wBhA!AM9jibtb?V>%QmQ!a~e&p3R
z>g$#`j=!;-bN%ls*eyuRTn_br3#HFZx=svc5jXU|yJJqH-nlQz6k;^NC-<i52L>a6
zD?Cb~{Xd^4>VJD}uCX|U8r)2L+enV}hW;PNo4$r<|L6MuSY$~3znIcaAlH+SkCT9B
z85(H{(zF%mxAJ@xwft1#jAZn1F%q;TwKbY~wk+xY&A@MsUJcxvpn!X*jzlAjN2_fi
zNB177L)%Q_joNKAtqJw8?ZLi<mDIV6wX;M2Z$y3_M>`!E5B-0UlS7fzRlt$!|2;_a
zNl5ZS<bMaU9QuC^(!3YBUWtSshpaCJQ}zFeT&*Wg=>MJR%e9r<o1uvM|74`ep4v;(
z|J&id8u;cawAKIHd(i*q6K_k3`vxG0a49FpybZSh4+8B>sC_U!NmE4A)z#3swRB6j
z`u|$q-0%|g|K)IaKcj`0mG&_8ejh6#s{i*gp7|cmuYoV8F{Y^ge>;4-9GI_Tb;UNu
zW<&p<3kP!je-+ZB{@+cG4>2Bm7@5i2|0~f?SCeiPn)FflJrnwzL3yjtq3ZvO`FoV3
zuc6ZZuciO*1peES{=WgvzZ2>C5;CR!e;E93VsdhG>C?b}1#rKX$+80&gMEx~{V$ZR
zOgp#S36ItPpD*kG&m!#?vb)H$N&kNw++Ldgf0p|CFm>!F_ztN5zlit1kCB7x%KHCP
z)U4M*&70F#;*0R=5U~CeqwHTp{y)xS{nz1{dPCCx?*k|G|5J<tKMvGyN$vl~O5dgq
ze2jf8zlfj1C3vKU{{IH`<ip^!7vBfl|F30Fn!bmw`hO#OK?if&Bo+O?oM#KDg-g*D
z$MB{<_1U-j3{6JX<^hAd_Nto}pw->8X;|uCssD|ou3klLlQ#o7uSLG5lG7UAh5oO!
zw2I<kp4-utQ-EM&YCq)q|2({6R-pG!r}XnU@1(Sf{$BxC#`ElDN&lY;v>TB7Q%JEK
zy|bD6a$?dd>i>0cZUprr*Z;fFv*#mwyOaJusa^kXNAvYH3<tI$Nn1`tOIGy%rAWYK
zrF(%T^#85Ixdr}?<xo%G#(JL}_5Ur@z6Yqm*P=r=(*n7pO8;L^-MEw`I1aSyfBhXo
z|GyTHL;qifB=t4q`u`8nFVm6RPvbwci{I~~du;#zdD8!1VU5xcP-h2IPnWVn=~AX{
zJb_+P|9=~N{OUf2G=G!5Sy!?=#naII-5vD*8=&=D@r&3=Z8^f5*HB-l;3M&N>V^9M
z2-@e}l-Sp>of`C25{=AEc~?sQdFt5<>;tR+knR6Zq^JIT7>Msme&n>5vRwcFk~g{j
z|0Ayd6Kt#X|05<PWSKiejLvNTKLPh1BJWZv-Ki8GVcDL(xBtgwBUsL5TXq=>xTybk
zXBGYbGpO|Svi|=s{A)u0&&>wnakDA=I<@mpS=vGU|0{N^eFmBNd-Ufok?XP9u1x*^
zIcnx#rWVD@(yZ)iJX>=8|4ld?`hQ6FaVFt3XU*B8{3b;E@S_GFo4%-LquX~=AM4<7
zclt-4rh}<9a5(9oZAf!R{c{a1>XpdbtI$6uB>i(*ulnaYFqn!iebw(t|GbO(a~XPm
zHnKT_?~3~8>K^pZTk(6l4mp1rGW~k=iTdYLN&noP^v_eJ_a*&vfbaUf>{WJzZ;blq
zRn+{7{yD&X=$`}B{>NT|{&|`OrXEM~v_D(`PruGr>|=bH`emVie!wE3wm)05LrB1i
zY;0*orv90eJy7}(f6@N@U$mIiKgVXd{u!2q{`nw!^3$d3sr~)3^;zhjpYpx973u#@
zYJX179z^#3f-)~-{hL0BPKvq-tu_`pZDalL7m%O7N%He<WaUxn*rRCC+xd>(4b^_h
z@+3b)ex63IKgOHSBR{@<0?OXccliD6C-!Y1QGOmr1I(ob^)=*2@2rUR0DHOoN!9o3
zIyAw%lKeajERk1V;m^Nc-$!eN{A|g7RI+wH%S5`a^7BJr{4%|<x0X)J)@I7jx=i``
z2jF^Lb_zB5Zm3v?PuPL%d1x^=o0grQRpe()c3Wvg=J%_VO@$w8vO(Es_QRf=wPcU+
zrmyguAQHvMP~63JysJE~-1{tlZi#sgT}wBXR)G93{0xj=mkxhT?>UbXZ}T_#dvoa;
zwD=j*QH=arJ4ECdBU9nS5G6)#k&~VRrtQb!6XSIb_31&pF`ls;jT*p}<6>dq&<Yp6
z1}RE<9uVmxAzXo*wz`hNd>lm#3<48J@C>HOgIA^ws>J(vlE(<>^1J+;`)BBp;@)K1
ze8bA4t<zC6{VM{(d}PnDH}SDF-#E&rb=i@vuEBit!*RYszR#~7I(iJ~iDeFs^IMJ<
z;}}H`FSEeZeN#-S^{8`j%+5c@h5d{1P4m#-!SS!KXloPjUCaQ|B5hpr(+^-MaA@^y
z>YP2#<!DGjP}^TAFK2_NLD}Gj{LKAcd|r{DJfDt5L{2&XrDdLH(APU9#Jfr?^9?$g
zBD_50Ro4(cB#|~B4b|Tw_!`nG7ffpz!Sl!|AH9`wKIu;WV?5091IJJ0zrG=I+nlQ9
zUtbYp`R8+e3I=n8{0oEQ3Y~*K^4g@FU8szBc67q0%B*LDQszi%z!P#PUn`+&-o8_E
z{2iUjX9*zk4*A!r>#P|m?MR2#)fm}U{vDlk1lKVM_fb*)9rf%Q9M`SLzt%NVh5TD;
zF8|u{9U&b7G{%WCwAhSKZ?tuFC;!IRLgyHWsp@D)^e2V#uf5B$KdI!-dp@x)xm#b1
zBb&Q)icycQ{smIloMOaZ?1VU%{}@Nl<zG7G@*iBb#>%sZp{GITU`}d|@Q<=CD)Hep
zWm-qyt^1(?&DEM3@~^fqMaaJv*{=D!(~i<3WL^u6BjoZ`*;3yqhvMlNmy5`H=QxdU
znAUMKpL8exj%J&S+;^WJXQNKwZvf97y>BM19JcInDb{FmRsQvP8PDNPMk7)g`oMG!
zAr&G2lW3PI|C7lf<lk}Z7@csQP{_YBn2$M!{D)KyAx77r{5$S79}K6^veiP|$P@QN
zWT6F~>c^t5ykkAi#&v{Bi~Bg}G>&%I1ai<mJf#QucgLHG{LiOv<QT2;@92=yq;=F0
zum!Z!bNROnV=f|pcW2hRFuxoA&H*ds{}||~Ex13&3SuvTMs@Turvu|6FwxR6BR%P#
zu18=W=ua<B8)Gj2Gl}0hg#4@1lu2blh?PktFXUe><~XmTq)MYcD0(3&mqUq{%fFWP
z&cRukj{hm0YB(iy7}ukTs|<zwyDPlfNQ;1;L;6L9w}B~?Fvno^`|2E8;f*_IDVwdt
zwQWC<d>t26{?!V~zuX=IH5|+H&RKW;h&hY+lZdJOJEGb-ID)OmL?eCvaUAxjSMfK1
z=OeKSHN&+Q{<Nj9NU@avspP+iUWf9pe?Z8;<K~^iF!G8TytK3lSd{<c%JRR6UP&(h
zi^yXccZ-Q%k$?AFVx3+NvFl15<17D*=~-s<w6r!)22SPwIMVFm=~nuh$0J``xH}QN
zwm^^mTyLfHao8)A{}XxEz5K7B*LwlE<n5pNj8~mrmjAP%bB1+n3YM*7q4C8)5%Ry4
zIJx|vn&kf+V(q5%&S5WogN^(-Lv9CjK91usF%JS~$p4vGOxMHvGkEHg{#c6C|BH#M
z{GSDVhte}0MEPCiU(Mr}-Cq27pc|L;mGZ9_+Zdh>M@p1`z1D{CtAtL3!^;0C^4E_>
zJ>|Dq`RW)<HHuoAAt%cJv?P}m`JX^Z)391JQt}+)g#6DWR>=Q!-s?#c@~<p*46Tfw
zDF2)2Kb?krIty_NG7|DX2g>Pbv7Gxk@IB;zIdP{TP4koduTPwwo8*6P$IQ9giJY&2
zZ;kXe-MM=Wxg6qe0CrsEe>=IH%in(BJO~sA;L=8@b2h!<Wu!h8n@&BF*NBu|(T)6{
zgXK8n|2k4%NQq5Y#nk^hsX>loT$*5d1wFo3a~1NxCp{a;lZyPG*{%HF3hxgk`9F^y
zyYhc+8H3}1`u$ih?@RK3H<onm-xqPd25Kw+Z${E~V!6oW|H^Jk=q&$tW3T^cyZpZv
zzCQ@9AH|}k{C^5rc{Osgl{mTl{|P0&l{Zu9vv-yM??J(j@TaBX^T__Q^x+TFhdzi6
z;MG{v@1?(g1$Mo6vG3Ejk(v*Z?{|Uxjg)yDxV;_w+>K!Hr&umu=tln4XbtdqJ(9i_
zNm&DrX9E8~;;v2dzm&Qc@~_9zT4YK2-v~|nK}qLYD*r9~%}?@`SkwNa{BK46m!c(<
z|D8z1FeEhe|FKBMTArOtx$d+Z@_#%KEW;8unzDBB{+uNL$53wf^1lbW)h0$LP6N|B
zu^ZoAdP7<MUj-!=Vq3WxDV&3y>JV@pCD%7`braS__5U5fcPkhVLWZwvhdaO635D0d
z8Rh@eN&eqMTIK)i<a&RS|1UA>VcPEj#dol_Zlu&NV3Sx@`b=5=pCkQ8;M4Vaw(aL1
zW4n4MmS5UC*(U5eA^-PqR{pi)R^)$BmdpPyu;ShYj|OGR|3k^{`-5(zvs7B0eG+KZ
z{~`bXffeirr777Vq@yu=Kc$|M{X6zg<^TNbe<S}VXV+jws>^-_7A=|b|4Hh_pTXNJ
znXT73_|?kg=Q<?wRY`shkYXJaIUA`8`PokSS0c5!{Jbv7&o%Axb8(WNi#lgd9?H*6
zj3j-Gt1Ga6{ULVVhm-tV#&|(4KktAOw;?}Au{XXKPA|jiH5#lwNQoaQ%g>%3<R@dX
ztWBkb*=eO|*&^(Ice4Q3Gf?%Z(ztAKru@vva`}0%EI&iDn@SV2k0Cz`pl53q@-rR|
zbqr6p)8`&6m4{3J7xZ`!)~*v7L6AQ8wA1H1(C25=Z|m0|VMAVwd`X{s;qKj~zeA7w
zv5VGs3TrcL0Kg)BzRFzAr%Stl`C*na|8q3(14xMVYg~42)|hS2{t@V>WtU-b``6N0
z*|$n(WJh@a%B&vUatxIFX{X#f-illt(VvdruohIVP2*h`QgqC${mwp+vFp;4{4VdU
zo0o5V9`B46Pf~&!Ke+`*JA$E}Bez+l2Rsi*{k10(u;fo8PS3yguY^YHk9iBP*QWPP
z*a*B2>y@#*vXxyV*dsL9J{Cg15JBCrtl2_0hIyK!Ws0f&$RfcWW>DVLS}U}kxT~;~
zi{O<ufe7Madp_t{e%Ry5_PyTndY#+H2unirGt9@s;J&kgncnWU{{!#zvX>vN6w=f+
zPo%j06Z<4ul)~mFP3+ZZoe=`(f@tr_vFj!C^r|9jN}^cXAM-k=f%owwdP2s^-_^=p
zxd^*L<gJV=g~3tt4S5O6M{WZXrko$Wmtbz%20ct;A5YoP=3ofgcn<2xX>pTcMS^_G
z<zKs%)+Oa%3CZQ(o}=8iPp`!?<UcG~waRFqbrJp2uyZQ^+Acx@wObh@Y-3_%k1}Ta
zgk06iU&~lnMYW4KFG#N|<zGKv*A`M=I72C?x4Wx~O)>c&MjJ|s4kyic+Uf3)EGKOL
z^yBNO7p|cq|KosQJZ0J!tR05a{tEeb&*uL0B1X`|tH{5(=o#5ep346i-aAt$@3Yh@
zAuO{}U8+Q_l*`(dwP_i=SEiH$sbVbkUXfs3j6KZdo3v44V|J|e^pJloWm+SZFr}-w
z{11W71Hn1uU(175TxY&$tI#SFx*_C$BxO6p%)WFn`IP?7bI~JnJUJ`>@^~CMJ7dL_
zpvETopFnwD>4`U#w_(GoMWgYwot1z4iP}Fx{wL924gH_XzaE3m+GwHl(X?xwZB-;_
z8Jm$(4x=AB7s%#7gNaZ^`JV<A^sCgHM)|jdRxoM-s$%fZB~8e`-rJ*S(}w(OmzYf3
zr<p^0Vn_L34o$Uc)eggHoh$#X<S`XYs^xzUaB4G|L0`hY<m?XeZ_lT82<@gvzN0iT
z0wB%%1AhjE4BEn!e>IM_GGp~k{#~m|eW0Bvmw)~LN0YOwiYf7~%cJ}|>qejdTpuM6
zdi+uTT{BRtr<ACcf9-P4c^S>w8GG6`TnEY3r}`rQQz%0(|CK<e{4W7s*P<Fpe=+2L
zE)eM9yc`KzM9X$4Z;Q!KMgA88;fU0N*IF|v$)xjN)c-T#bjbf!;8>gFe^ZY%seaLq
zo>4CUJAiH-{pls7Usaa>)yVHwTF|Y?X$g;rkpENY*A;_5m;Y__ad!aQB}x8Q(5o9t
zuDSf5igZT%XC;=Z<LONnmH!>|5jMBW|L!FJ=aEA_J%_ze<q$pl-AVqBQucPR83Bf;
zQ%W)Up9Ca+Rh56`#IKb;&wjr$t_)Mt6Tfik&PF(`{D(~}Md;;6{XZF*2>G8!YR7Q&
zP}cu>A@V<mt0_EP%#q8#>$^?vCD+O;<$oL8+D6W9aC{6JVKGuO5Du^B`eeAhfpbOv
zPr)9f*VOV#CcRt@$3mg}pASV>((~U)IhRBGad3Df98msGqh~dnc*_4CaNQ4o=EMCW
zLHRf41ZYt$|9j~zwnCfNB>6u`ndj4YFCnYS|D}|<sYv!f_Y`@k*Y_izbLm|_p5*^d
zEGEO~p{_=P?&~D~7l7-jcm@>-Z^6E&{(qt@|Ic%Gm>j=?pXg3J)S5YN!Yk!naP)HG
zh5UaFUKi8<%KvlNRa$}k9xPyYVfp$?=zBeReh>No5w@}2l>T0NzRLfdeU|^}<l<Lx
z0Wv=idbA+zt?lyP!o6HqKj>5MYJltD$*h9%qx|mxS1q^8;o+Jj|9VJO<o~=R|GSaW
zV<>+F_5CEMwWA36iI>a&xzzfT@dUc58~MK}$^QYQbsW6C2l>CGApFYzon`rd1X+3t
z3()2G2H%Enk^aic|EJ){+p!%f|9^>1Vn4hoD*x}pg7YGnz8||<hE3)<uJ0wMU$JBS
zN3fy}&hCNg%KuMG|IE9sSXaJ`uT)><{{ukvTda4RvkSAoL;v52pW`sRihf*{e?6E#
z0Odabrw3=n<^Mt`*#b8!@^f)neon;#H<foS*m^>Kt^kvh!9@AlSCIY#iMa!4m7lwz
zj`DLoJb4l;`UvctS5fkL)WJ*O!ZPeitFh-j)JOUGA@Ki@`g=NS4A0M|XJ3Q2@9UsH
zm7jNGA^i{>IR%^J3hal)^yl}0>_Kc*(&ufdeqD?%c$E6}=ZQWKmg(~-82+@1K0l<a
zA|a>GFQCsE*>l+6>PqXg5t;P)dTB>?6@KsM;rBN^dtJ7ybU`M4F3GH4O<9rr!_H;Y
zxH3)LRZ{x}4SRt$gSg9Mhuy$u_MNmoX#wymLf97Ug@t_}Y*euhLBud8+k#=cGL|-u
zuo&6Hu{Z4D8%I-(tvx^5kB-zkgFjz^z*dMoGFx&6A&dDbwgJQ}V9n1t{^o98KDYF^
z&ijLbzdcCt3p|6o_W5#Kk5&r%lwqSG6GHeY*!R<(BTQi((a*_XiX4CaP|Up=e`l<_
zPKNk9DlD#!HrqEd2&d!C&J}b9s;xTlx2JBf@9&&`S15_`VR5wGKit<TZg9<V?TKg~
z)7ofHEyrIgo&5rBRNC0IUIcyhh0!V{p7v6;6bOIbdUAG{Ys`xOINrG0v*WxK{2ej0
zRpzR(;vfDOwipbyv*(d&DyeOCPo+IEo9{`Ezn%?Cc#`99t?h{aLNw88z8Qi4lu`>Z
z7IG}+5RUK)2)gU_FcfIDj#TisckB#2M^iKC+K(&O88HO@_BRIsMc_Y?r>*I&qwOoW
zb7WQgXOO!seLXCur5Fo=%{g%;wB{DBX4Cp<NU5vwUx!{DM~rj8|5UW&N$vRWM62!P
zyDR?3!HfOmv=$0%Z|A@GA8p6~e9B)B{_B}TWT@cp3MXTLY$#t3S30px75uN@zZm=%
zfX|{1_^$x+W&E9rj++brosVhT&LIBBfdARxe>(UdpYT7Ec;}_}*Ou|$&UgKG@IS;D
z*lC^czlpYy`2Qha=U37a+Qk>(<z@MQ7LC1^Z}T`>f#Ux)zCZ7#ZMnTXR#gYCf1L1t
z1LHv%I`bX0s2<^{;J*N9Tp7k0z~X-l)LGt+{}P@A|Br`?OVgayMYOqt|7TF<>-lmm
z1O5kqUHo4T{;#ARVR%m`{Qm^}Z=whDPB;1`^v_l^S~V7UM`RNjwfVo9M<D)pmF54t
z$p1}z)&GMry3N_{tTlTt-=<x}{d7vNSHVF_-HiXh{sjN2P~v(p&iN<&mvP?+<%Iv^
z;C3e?e@9b#;h&ia|Mcuwe3ie<2-V<hJ~I&5pqB7e^8Xq6f0q1zOuJ_iTz(C{(s}-$
zqxMzj|BICWsac+X{+)>LOUe>1RNo~qdi)8Eoadr`Fl`<xSNW69=lH6q&$Kt0-XnCp
zy0}&d`(edau68lCI#Rt^E7)uE3zX}0wZ0ZWM=A1ekTH4+_9sKr`m5H}(@*~nHF3P@
zDXq^fOUsVlR%&lYGh78s@7`kgTb{A?0Si4IqZ|6_*0xc{S2egM{p0&8J&TPnm@@ZU
z4E_Zt)l8LE29bIQL8<tj#kX4i`!(|`p=Gl7;OK+&7FxgTS_W*7NQ>}#>^*((U;A3L
zX-utmY4E?cjkcQq;X&s2)33W8X?@}UFm$B8Y4(wV|4rpKKyMi6(PsN%Ecz(;uYR}9
zA^&UJkffM0XxquLqG(@)hk6kUyPoL5f2pp_2QO@;;6KnC=;>X~f7?b)<P|H|X@%74
zS)2d1X@dW*gJj#p(TL&D(3O`$$Myz9V`}YaE!X>a0%`S^vL$5wuWbWzeu}Z2w?CNF
zTDOD$W6{dB(@T3>C(Z|52K|=sJ(T~mp=4_z{=42o@Lx+-3uz|uyMm)H{Ev0;<fQGZ
zp`>+1f~Xz6(a&$MUb<>7*H{_FS<AlsE5?7<Kd2|oOpXCS?Yb@#Q~DX?P%F3!iPn$|
zx{c=R*#P&JC;qP_SFQ8ChmQO|mbS%0a#)}EKa&<qtuO_Pz==fKT;~6olzMDQPfPjl
zo8Cjt|6>yWSHk~2W&W?nqiI|3iFvC}Uhw~H+FAQ({S2oSdLjJ35PF_fGrg-r>8&}5
z*p5}&my!RI`BM|s3byr!BlQ_n8wMYo0iE-I8hwFUVJYRv|CNdVi)d$^0R1M?mR?Pp
za%rvPv~+X+?<1cBSUS#w|0e?ZmE?Lw&Ge@uY4*3qGgIt*{JMhwuZJqGPf(lxufW!L
zBDRZr@%y_JYsll!{q3}255oT&liyYEAmsdi7!MnL(w5NfjQal``2R%jiFx})EG5DJ
zKZpN+llcEN<_QP?zgjc>YP8Il)Gl3^_`jl^|F)oO^Z#txo5z*;zY+dlNbhDts{hWC
z-&M2x8x#M}WOk(W{|5Mf53S#qV`aUy5dR;5|F5LntMN#x@c&utgI8j?{p*_LpH5%p
zE-XUttK$FD^ce0*{Qt|E>1Sub|C6#=SvCJBWq77#JF{9Dtfp5G^uIEBEnZVa|1*%Q
zTH$OgaY6qZ!Qz%O{jWl*i_w2t_6g|rE4=ok|CH<}V7@3DoJs$G#F|<wd?dkdza!xP
z72H#Q+>aD|1Mk9GVN7<2UEqF#{y2`_Q^5b*(&9|`U+h7CD!q-a<c%JPrP_<A+*RPP
zRTDY*h40+M@C)cO{ddeEtU#62aTQ)I6`!Tbd)p#mLke4s?c?g8J;?bD=AgAqdsuZ4
zBj?e@dU4%<fpbfkSai-`TUBl!>kj{T8#8?z8|aFEtU+vlqIdlDZP3S|W3W9I_`7FM
zcv4iyaAubHJN9f_t1JH6!<zU4I9l8t{`Pn5Ddg6^>fH4e(f7jEr#47?RULzE6x+$p
z*AoBE80ZJ@dW(U-t3GxNel6_r*xDBVxUa;SliDxJP~hKLgNnai!3$Dfe?~X>+m4x!
z78U<#v;#Yb3jW$7JGZc7bzNIu;y<zn{HKEd6f|%DE??+rd=KjR?mFwJ4k)K}Dt;CB
z`fpF*%PaogSBEpv+GF^NEdhVWLbq1G<a%ov|BLxr?!(^Hng1L3hL1+4h(G?aUGQ%P
zI#>Ub|Mri<3Rfw_6?tsQx0YJ?8`<T(Yfdhsjp3{j@jt1OG+j+&G_M{QE+mI_;2&17
zN+j{so^wgU|LiXKKc4Wvt&IO0yWsyg_}|R9Nsj+Dm8{d%GnD<N(%)j`c?;k6cXq*l
zNg4myaA6^Q>Wcpvv>F5d)A^!w#_v|X5jTPVZCLWIq<wgAr}6{;@8FLe_<y<6d-4Cz
zcKm<T1^){(`M-uSF8RL>FYk`waDx8~EM7Ay|7zM?9m7$^T^=dJ{{i5Cf5+E&LJR+o
zSzqB0BPjpY1^&qY8|42U^8ZDb{Fi5W{(o0GoOR8=Q*q^6HEsOm-wyS(M}D7Q#q&z+
zcph={cX^shj(O^Mljq&}9Jv^`5-NFk<ySAx#)vOqr8IS+@BOVjjr)q8^qb<JG4j~)
zoryRVs47=EWIpK_{8oh>!S8AQ<?;&=<(g8vffk_1-*_Gd;}|n6NuG`Cv#>ImvoLxe
zqawZ)+Q>ihi4u5`(t550t#9FZXkO+MN0b}iN57eoe+5EuvF+}cCa01%FRhOeguyWi
zkMRBryo}@bR}V*@7$dh-3Vp|*4NGg3!E}Dp{JNONr&_(l%V$1~GV*?Vv{OuLDdJ#k
zA@u7IIrxRs+9v*Sm^!4O^7RYIy258%{V2^rTacc;(lheZIwx*XYRIZ%e}0{%U3hhx
z!d8Pg1*db%pI>tE(n{sG&iu6)1*L=6e)DtAc7@Loyr8naw(>&TqAB#HGbepn<0~4T
zgQhT^K5$|e9@H`38TLSDsS0hh4uvkt6_1z&Eghw(lospGUpXGPhoGL;-{7@*#VD5;
zOIcTk)XwM}NMYCJBJ|3gZ5iPW4{Y&Lt^zM(NNX|BqgaSzWKVphezcFIc3{wzexVD*
z!F)m^7%P_+uR>OY#yDc^Gyg)?q(grAH1t5ktJEITm|K3Xl;Lxa{5M^ef0X=qubf0~
zazQxckMHsra>OUb@~QCxGi}XLc3|VZk{FVs7BEHBh8!Am4QUO0iI7V3TnXZ%6q$#T
z7d0@(m2=5;+*|9Zw#z6>nKjs&4|{6p33Cg3tMw<SU9JCo8k`M|Mm|bMPxP}5X>UZH
zs9BUJ$3wlgP7Af8t&Z~t6>MQ!3thR|IvivE(eIJI+GCVMYkpH18uylPRKgsB2V&t`
z+SaJv^q+0K-u0jU`_^IqV(cXL)>Thb>p$nyR`j3iUb}v4c=lK8zaf+;<;61BLpf)I
zio9+Q*3Ml2Ne^r4Fw&_nT)QCGe^FbdL(EW?Q+nV!e?9b{t8mAhccsM|EDe3;=!7vx
zbLXny&P9oFZAZeR&(jlswM=)^fBJ8S{&Oea(0?&Uz*)lvJ*q?hc`v+yPgB_*<c$B0
z`Y(D>!l&+XHh?(T*O78V6O>$b6Jo9NMp90If38z5)hhbWH6JE`wcg1SdFzfLuA(rE
zr%JxNvyS6F^xqhstN-+l_f7aZ=%L}Nu@(L2D%nbvt4Fw-dTsp|9xLiDHHft$4u9iI
zu0%(T3_TONC%)5`6^AuCYHsKcpUXR+S=&MjMBeJK(CDGTaw)7Pqi~o$>TX5<$suLa
zcjjgcr7HjW2H(xmFNAtWDR#`pHio@m>$^6J&^LbD<LeiBMV(bIm`Bg_%SRFHD^~Ph
z=#21j(d#r;Z*X00*J5z2Ki7ZOpnydhIVuq=f;dw_4di!Ceprt1DtXo{A#(2v>xce0
zJ=Kqiyixz@1#c}2{pU;zedS{v7&U_XhUgdX%o?o+x&BkK9Qn}mXDD$-BB9o=m=)rF
z#qQxDjLNGyNNraZABjY|Lx=E60Ym(z%kqzN4wM|d^7U?s_MbJhKBZL;IDVw|b0)=P
zeslddk&*)QuyJeOmwRH-QU5varL@H=7P<a&g?#16)IGsBg+98HGljT9I)f5taqSx9
zv%zyJa5=`{m|BLl!BtS^P}UUUhW>M966aQEd2lC<38b}LM<raFU>1LqlZ9EY6~~08
zCW&x8{b`B6=H3&0YBN{yvAr~lGOg{SiEpUrzoqG3%ZtJJ1yadfF+%_8hwgaXGR`H&
z7iRD~fPB@9QecjciCwM#rs5Zs>%ZCQeRn^@=m*=zTZ}~_*MAF>N7Y>Lbm#9z-r(<1
zYQZKl0PBVRI`;k7@FdrNGl^v`>OZ*<`fo0|&H}n=;5-K@nMn#)fpOjIh1@lemk_gh
zVUP54j-wK;%vu-Yo9Mi_SWi6Hf9@=09n?QR^q(yYcjqyl`a1NVqeG4`SzB#4SyM7#
z@R{>6-SNUXeCDsd(G$++#>u5HU6y~GQKhxivlcnO3F-jlb`&|-0&(3bRxkxu@yM-;
z&L(iwQ?29LH%hVfIP{<Op_v@?nu{-)Gge%gOTQxPqvO@?I%JF5REGFXm*t;naL#py
za{V_JJ}5KptWknHrkTyPd&Rg*Md&|mZw6-oDevyQF^Za@{+pTNI99Fx(_hZ<vuWIo
zqa<M-kZO!;&}aqIUgvBsLs$4#Q@2`4-Hb%I2hMEnrXpoCuy0lL-$L+Q$XnO<5Y}c&
zn2Hr>I(20>5YFeRdvh;D;?#fo(G4VrT>s6XlnJCZ2X|$0N12gGp{oa#$i?{?hOY2!
zA+LGFUqxE=-vVf_rkjUEZveAu{kM*B+sRn%>VRJ#!i_+<AkjG2e{0FfnmrSK+y3*;
zwo6C-XX-4~$hqXA{+rn&d{gkhS_ZD}xMR(8kB3=Y>qB4Bf6Ixb{yP<mR_MQzNVS2S
zGg3^!>+WP?v@&DC{hHN(E6G9qcLvX9F~T?pNYsC)@$6(M=YBoEtNuHMyrLaYOaGlg
zJjbJR{dW%c75#S>)>4Bj?UzcMfX^CO(SMtPwWr{!CEK9c%Nec9_1}S{|MroC`%X0S
zW<GSdkP+6+W&L+CR?;;*$*^GB{=1l1+px8cp=?+AQU9HVeR(mX>FPgyFwY@Y3-&<u
z-%-+E3@<|e9l{pfll=MBcJ^B6Kj+Qrtvd?XCUJ}cX6GuoFOBwOSA4S8#7;WO*w7SD
z-&ysa9JNm9fvWzqwV?jf8Xx;}^&_TU6vIe2k>`GSqWvHRyVj49#8W4D9)x_@qVQ`p
zjl)&H)G+El=gX=8+|5ZCt#!_8tJZ&hfyGV?)PL@qRIUHC*3Tq;@K*iT%KP5+--*;h
zcTaI0ss?I(uK$)&(wqdH`fmd{t%M(;|K=g(>OcKiR#TTwAdh<TQ2#l9XEk^30yUqz
zDU29z0Mm~8ZwGj8peCIL$JKvZd*ts`#N3UQU;TFh_3<JgQU6_lPTB+=P6Fz!yi@<3
zL}_wkH?d!aJgNUKC&h6<GMXpHBXRC;vZJj3E<+}dhwnR(waJWSo=pyCle;TOU5=z)
zMSeTU@%$S4?+E!<^xtVvK>c?ZOa8%B*DfXRdY-Oh+*<wT-ZZY5t^T_PE4UhLJGAXb
z3*snOCqa?(;PP3?$5j1y2{`rR&1jAxtdsAq60f9&T}>{+cd$qLy#nl(QOjPD^xs9y
zthhMozk3;1zX57YrIucW=kO!IdmbLHTX@<AbwmGMLB5ZY_IOrY*}*)O_aS``Ff#En
zFxbp_Ailvnf#*ch+`_m?E3pR>_s!Jo8=(GmK<n4|x*p-P{r7sPQ)&NQ50=&rS1Z4o
zU)#>1|6I|<P-*|&!<{QCh5q|od9>k=;C=V{?+Kni#t6o%IOqD$)#mTyzWZ=1^!fzY
z{V%+D)qgiIGV>y|djq~4_b|ikOy2zr{)hg14!S%}{udJ`^xs#L{(FH~pXi|fZcX~{
zQDz*y6KuakPPzVj7<&FA`tJpJ@i?<oO3Y#VZjbcyYdR0P=?}#h!=33sur}#G_Y)X}
zBsK7)qW_Lbwc5Q99Gz-JvelDgh-=HjwdfYM>%VDb{WlGY>+`b`Zq6WP6MEUbW{!dO
z>OY@{=8NBIO1f)H6IAl7|Gj$*ssF533!vIr<h=<P)qlqUx%%&9Xy@8=n}A;Zw=uQ<
zRzW9MJ5&FyO#1KKr2qWpG?VWLU>ib7wp~txCZYe<ky8_?dV=pnWHt2P8z^ZBHDV%P
zBU=mmkdj$k=lbuKPWtb3@Nj<Qjp)BOBO7<%&Ga&A!6|rV)Z-s>1%BQusUzDNFI<2m
zp8<}x|MsF|)PHZHR=um#0({r>qW}JucwfWkNd5Pfr2p=L=8q)(_kpDUUP(Ps|J~2*
zFXi}_r2oDOt>1|>yuduFr<wN^`tMuJkW~NO4UY%1LY4YY4RJB0e3mt<PU4uFJf$vY
zJ)ysC*MAT6NWX6&?RBh!^abj~ql}4uoK)XKk37f6Q2qDa(u2&#3;p+e(tpq6_49dr
zdaCu`L%`Wl|NR3#T0cbp-G#m>v0Bk?V15C-U%;QsnOW+;FG1D*T>rEe{Wm+?!L9)6
zzZa2@(0|{8yC*RRU{N-fxoktST>lMZZon_`u2KK}28sG7c&PrHo&B1*W4}fJoriz_
zscB?$B`{6No@K^Zmc5photA*@%}}?Z{}!<Z`gPEwcm4Nj>hBfA+lCgt3JrV-bXkiO
zPh}2*^>;7Qb#1D@7a?7)19~}<d6XmS?;-T}ZX{|WBdV=nIgszkP~hK!4DLbZY`^S5
zw_AU&MK))Eg>z=FLKa_xR9Szo?WO)6?WX?TMw+LQnLEh;88{U6_jbJL-ihwIJ=Ncf
znYZ~M{JxSJwGloI$LsD!Abcd%-?stRrFc(`0{4fgCGI_T1o|CBmTyn>_l-QW{o?p{
z6RCQxzl*c2NZc^E)W9nImHOMC85o~0{T!&G{c;OB{3+tqm!78%JVed@QfYkl?Nomk
zXYXMhuPc}VYW;2HZXWB(Pt2nJF3h6-el*qJdZb|o+I(U5qteE#1^7k*K~M1grk%h4
zlKA`gQ2SZ<`>qcBeLMB{`|$VX#NQtxg+Ii%@ag0Q@V&&}PbL2TI`Q{TYSrhU?TdJD
zjit`N2$r9uj{jTY?|(7p<X5GC0oMP3H?{b?JUfN>qcZjLZ_4_4JIGv}wXibWNM_XB
zMNM`cx|1{cyCFLn?=x&0S<c_qY$Kj@!%JspH!|+OFZ&L3Jqx<Z-*3X-OQ7PC>|Yaq
z7i1qMpP!e8WhZ5aDYun1=j89ctS9<G-g0mxC|cNYl|S$OT$j?suj%vgvffiw-kLH}
zh3&W>ciKf>O0bm^wtlaQ1?`bBBBvEq`>|s|L9JprIF>EE+PnL4-9KFyOKU4Cpw7pi
z!k(?Yrf3l37}M2i7c+2zszr0i<Aoo9@D!(?_WKy|a!kw|ViYgWv({O=oujaF!BOy_
ze{uXxtEEiaRLrxL0$R?B1;?(nqC3hLBkc08xAE%E`N}~@37k2g44990g<`?^rjBiE
zch}|@a1_U1iMI`>U0hCxiQ|edCCEKTp8CRn$00^hrlrb%``YdzS~SFHoNM!F^>kHT
zSD`PCzm@`L7Z2vUrysZ@K7HZ8D*(A`V>SPK8?Wn(mv&u8BD6sU|Fv3l_Im7`s&YSt
zbk4zWd`_E+*3y`7T#3`$m2+*J=i>UwuC%VLM!U>Q3F6_(Q?B-1G&omy9@Lvm%g3>f
zX0F_4xM&zfJ4+jQKl%bW{~Zk}8Wz#VA42OU_&=LmCen|YRWvy*Rqa8p_&x`^&xV`&
z#1^mr75-08_NI*1<s$ldMZ*;OVDf(+P;7h&{9i?1t_fR@{I^Fc|F@+6T~P=s@#^Uz
zw$Mj$wd<lm%gQ`PgeKGGbFH6ddJgMfBL7!Vi<VLUPwE5zFQHYpDe->?_5XZY_!H^#
zcJ^BB8JnfFqbAZW4*p*R|FxSH=l{uAH#R}@oz$BJv?SfNa1m{>qTwQXAoBkT`V=pX
z|84O97FyeTXt4(WZ~vY6e=q!}O<FJn|8J+&{U~;++tTdzxAu|$`{~77|8xGozYqL>
zp1$s5@c$@1r5osDe+F)Tg5RQHDQ$fDe|M_?7tzDpz%26O{Qq2;|6isjCI6r4Bmci&
z`azlh--UbkVe?Y|Yj-OaR+avH^WT<wrRNg;m!Mq!G-CKH@7LsMJa<k}d6vhH7?oU7
zqCWhX()O77`Iq-D>?u`B%dgEiVtJMOA^XHTQ|HfopXZjRj&tPd``W=CPu}wqO7Eit
zTjb#r80AE~z$C7#p^voofJ_~51+<Z;J)}zB#{T_=99D6$9NVz*EPU=_yeV*tYduEt
zxH&%drGgs8p^ILl<yoSo*?S6~qJSW%Qpq{^8)b)|W$@SDgT2pqW***~Tl^{k<`Q%-
z2BE2i%wCQCRQ;GdM~S)o<Y%GR6DrD;is6xIT6>qmEG$APmxIRM>wD;*<@vm5u*a+i
zmVMah$?Bz+<LOiT0`{?u7jc9(ha|@=QrP=6X7u6x6>6X5C4>*0Pm2Xh6)XE!Vk~d$
z;Ra0NZy91?sm2z2<9M%^qv;||#5J`&9AiffxAzvg=&d9*`oiI&cnEpS3KJJSj4VI;
z-@Xa&d1>r3aTX8b3Z+-lPA?l}plFEo4WxuPhnDz%*n1N=J*)EI`?)8RnaL!ROp=*o
zChKIK?EAiukOT-j3HurX2@nh+5KvIW0Y#__Vo^~lxFCX-MO>=ju63`q#agjiTl>1z
z+Qrtl{oXELzyJSS&pppG%QMe2)bIP=-|y|2xu1JG%e9^BKIb~uImg^BTW;C&^*Z{@
zS^z9b{IvxLr_clsLw2>01Wdvf{I=KYonHMxcaqc?^z1d2<6v3<gvipB{D4D__*B@0
zTpoo7upWl?dP7R}8WvukMIQD<OZ8X!nM>`xTkCFff<*6ip%XG|gAhcmwa*(~i(`l_
z6@)$498y&4h`0s)h0V269Qli1q4$|{F2%;{T7$SNDOxUK9W%XvU4P5+<f>!sa^HLP
zOJE|b^4E2CrJJ5T(s=|=ge3Hf-c-`iXU5P*U~aX;r(cy+QHu0-iaM&#fq3dU6|$`c
z6CNSfq9RUuG{%=IEDCbhAg)?f^#~1IwK~LAcwW_BKU_`Uks0&Um(#v*uK$EskAToM
z#?!w`xa3gyi>d#jW=f;bf7&6GPwhaiDko>8g5Fxnpz&)B;g75rdPtmo<5qGFDGcv<
zS1r-QO<zyvmFfo<`Y(Lf!&_ULYvXcGX<ho&UKMN3YV%QxTJ!Zv`_1b=OI3dKBh}kl
zzp~JO`o)FyNq=qebl#|Yr|DVeK8WfBucX~X&id%p8uYDJ#$Ej`{AcyX*7s8{T4~yz
z;85<QPUt`TA8ou-;wExc(tpC2uTUo}?!%~eu28%3dF&ZzovStIGucL3^`Dkd_cL=X
z;?RFyh5mC#Kdl`Th!y_5&aqYZh=(<~T>qKJD4+>nc=srD&1=`?@oDY-tMTL@mYtLw
zd*N9t)qn0O=b@jw(x~T-79=U|UWU<T(&xvzGM*TwX#s-C*tbIS#me#8FWo7;lV4{X
zcwK8y|GA?<=s)+$)O$()t6cw00+yHyp^dN=za4Fsdi%Emt+JuFb?85N=^kkA`J~3w
zrrDV8-REg4e`2Psr`Dj~VXpsNH_u(qwAML~xRZN*yY(#8A3OA)JG80)T>U~_q}G`P
zMPgNUJyJveO@j;W^rs)G@Jj!f@uBS28eFS?CS_^)bk%9cQ}q+K{7&xO2TuK`KXvFo
z`CG34oU3llEZ2X|fbIm#pjNK`W>SJNJIJlp(12ZM7Epx#b04l5Jn4cH?rd4oe;vdc
z%ahq)GP95V6OQ(jCf9#bdp4X<|F!Y95$lusuO0aG5qI^--*j;0O+5kiaGeG=b0}BK
zy}Hiz9i7`U7bxZdP3XVbJefu8M&MEZ%}=yb=S)sKsSUzK;3%#O$w6;!_bhcsNcEqq
z=DV+?J1I<tYRZ_jYa)d*q&L4Q+ejr3o#*0yl=bA~3YQBx=lX9tQ0gzI{+mw@wFV*T
zri4Yvl%9mHk~s-Vv{TM>VAa!H{ij#HtEIayWeZTw2QT&C9B8zF7>&eK|G5vqXr3)Y
z9@TWqsT0;HYnndG%hJ=@_1|JF)Vcm!0Ccu5LjNs9Ry;c4*&O82-Q4OauZ_FVe|qc5
z>5~4F3zNt(_O*1id3`6B0rzBbQUA>$#c=dr7b%ueuAWPB$h9h0V96T?CFTI#Jj!y_
zdH3;LNxcdEr$1j8an*mb@K12{uNLAj<!=G^>v*R>X|Dg)@vH@3psAF#2#ANH|D0E#
zM08`BbN5R1-{u5!C-;k>*aUKK13IPObzGNI)@*o}>%XPoqbIcWRKMym#G3&})qktu
zNh|i&W#qe_-=*-!83nb5)o^ngxs>$ZGRj^B%oBlE{kNQ~LjUQ3=DsxxfqF4zyNZUA
zx&ZuKtHLLZT)PhMDpITe^kVnfVq$JX{`8vOFpTkuMOedUF`|&`zg=Li{&TIPEznFq
z@dh~Ffrrg1eslfjKD{GJ)c~*bJ9AxC<F1BUn}Og&uu%VP0LsPq;OJ!+`tL+a_|5CT
z4L~uAv55)zpzi{%Q-OCGv{cu*qh_xEPKR3h<~J}3q5eCA`x(I2!d0~YHW7P$t?b2f
zXe~5Z$(V%tPY><R!gjbF`p<Q`^f_Gug>(J49BDg)C+feGNx6{tJAk5r)D3t9os4X#
z|2C560{o7)^0y8uo`Tm)=)b*SRcqKyPTk~u5q04-a%u+R6UpfWsB${6p2PS`BV0R$
zr<a1c`p=zE&!c?xpZ@t5K#%pvSLnYDoZVY-3o&+L5#J7ex&Au^4>6x^sTDkA;~+dc
z5l9;F#A=2%q5n1m&DwOF&S=m1Xoi!4vYyeL(0@B9XD_9kz&rO3IDy!v3H|5l8*9i-
z{dWPdZblw11m9DMeFDGRYKHFubb|VC7v}~>Vbp)uFrIJ{9Jx5@KRk4xllt!vWtH^b
z1&sWt|1JcwZH(TWKn@4_TYyj35%M{Y9QMGSZTz}c$qCT-Y|2vq>D^gdm`)AL_212m
zZj2;t=)djAPw2lhfFShWeqcU_xd<)rsigl7;VY*8lbc(>VmEdFB5+avU7z&dO^jcu
z|E}fj3B);48*s$R_1`5>ehLye84Ryr{H&z^t|wLoH7=v9<<x{W%2))9qoI}h&ss2_
z=S$$*LFj%J`tRJL{@V*Aq5ob&%v}H70v&1%q5ocw1nZN3F?^l@mR<Ous{i!6ei?KK
z{rB?1<-D7QkKCz@M=e60F63P&KE`(-!CgqG`tJg~(0cGHTSzV619uJ<_1}$1r|rLc
z!QeNq|L#Hm-2em=@b`R6QUBczEia&~hoH=*XdByq55b2O)S~kk&$<Tv_b~TI@Bk0}
zx0l$j!y9*a`tRjX;7M}mVSMWdP;AFP@(}#H9e9o++4?bt{?lLnZfd4Gj2=$<@3)}S
z+kr*>_fC$p@iz?p_h#~3fY;+z_BFVdy7FGUx$gkJL)81>=)adH{r6nbe-FXG-%I-M
zQF71q-_?u`_SJt+L!Wmbk4<>zKEn#%5AgRIWYYHE+l%_|ox}+J_c-*vjha4z)qFmK
zUV3EM`tK<)JHj5r>c1P1?<3^#C3xlWF-AK-i~iFK`7l1rx1mQ~PD$@cdwD#`yT|x@
zl9;B^*L5Wl_6Bmgu~+{+0v?|yr;iZ(Nq!%zwR+%-ct15(59`o>V*SDZ{dY^!e|j#q
zB0p_N{5mA>Pm=!o8s4W*qyIiu)PHYJ`tO}k_>I($*CLyr2j7zZdvKWg??X^zKC;&h
z?tfR*e;)znPoO0}Of7wkdbk#Pd;qF_kI~?B@M8`AcOR6lLmq$BtN*@>|Ll*@e-E)v
zd#?ZP1Sj?18^J>T_i5t%v}XE!1lhIy=lq0{{`*Iy>3$^T4b+FfC$Bs3C0GAF%?Nks
zzrVqcSN-?CUj66FTR%bn{S>IbgZ_IKS$rOho50}x%y>}$J(${m|E>R`{rBJcuYfH7
z@2&qFN67zd2gIM%D@%3E-?%D28>_b97>brQ<9jyvB(CF}U#FKTZVpGJGmlEa5sm!M
zeDaZ3uTAB+c$Dopgk^glBY<A#2bVR5fZp63!!QV?qZ^i48b1yQgv~L9N+HI2&B1sj
z`e<E^G42@sbu=&Vw2b`EYs(jl!Gm@$-#cCvV{1b0_?3D1B;Yo8pNf^Ea6z>gvowcF
zA*a1(M+UX1o3|x8#_33oqct)9kkda#dMqXAUzt9R7@41=qA}_rJ>;LMeQVB+xwy(r
zj;U~at*uR4_Haf7jqSLBBU-{GK4KEqTgMNiWniS`%Jy$%_=BdFFFaxpdq#&;n3HX(
z@XHQZ9bMGk?)Zsxk8xTq1`YMJhVoHuAv8z}SLD(%@7cq?gs?k0>d2gjqZ&b}%I!HR
zuXlpE3aj|Y3$5=;l=9-v)Ilq)#M+J>Z<8O&gZP+!@DTFpC}zlK_-Z>s<%n7?pYGlm
zc}DK8x*%;FQ89<g@XN;-FB5Wm(2lOectVV3EAPf|L@!1yVpLS?iI#Znjg{+{wm<Q8
zWeQiQ2tRE{J!4%Wt?NP?@-KFBRN6UrJMQI1rJ%g{-f;^@2A%&C>s2_G6=P@eHsoLG
z#7Y^CmWpl2RPFxaS~Rsq*_w9E3&$fINmKr{sW|GXRF&l45j=g`2M?~?uhhqwv+LO^
z|L$t#7>J{ht|;qRoD^}aM0s&{3rC6^bFjq9^*5LQiNHCQyc|7t2V+-=8Aba$R@QMn
z8^=<DX1V;k7e*^@Tp_DcaKtOt-EzdvF~D5@EyMKMb6uThJXt9Jj(&}xR~qu~Xi7Et
z7b@*!j$69APIKy~x`we&^!9g+D&^mKu<qsM8Xrnlb@_LVfNA73iM+IpxUaJEKb0qw
z`EzF@eayA<yQhU?*h-V5k;?z1RJOPc9zy;d7j=&-$6EB3SN`2`Y#RCLvF;4<7=NC?
zwR~x(v>D{>y(4y&LMQOJzRn!-9D}7V<bMWS2wuAOiQ^bj$d!2953CCqoU7`Hqw?>p
z;@U&Ve;1H-lZ)1_(X{Pd6J$KSh3Vw2{423jprWIvL(9J_9k_SLY*NgnM=b{zC;4|(
zkook#N7GAkZb7;HJ5t(B8pp<3NM9+4Wf#<N_bTOID?=0g7T0NVZJ33W=N`T@z{8bQ
zLjTVOpJtwh{Ldprr7$C<>LO(>|H3()5?!NWDcl`Tf7caR7L$c*8aetgogP;cWlE<x
zRpoy%ww}4bvI2Zpk;=W6GfLEc+yE}h|2j(3Dm$OPWXS*GBo_-Qb141qIwqUQc@jA*
z|MR$;M>!kmpHC()<$nb^t-yBFf!#&<Ur2dtz@QtxSmG2)tQ2zjUkx9Q18?PjBQS^j
zyDo+M^D6)I;dv8Kbio5xiFSqP1>C#y+fefF4EK8aovwL(BKgIB!tT%Nx;WFwNBLhu
z>6^Gao}&vMbQHFOk@BxS`NT@#5Ar;h|4mrrLjG4{H&p&N7Uh3+nfz}{@?UvAMk`bf
z`9A}G&ZYOi4yexOnPV2pzbmYqM@b?7$3dBqz%FmPu^ebKcBG|Ja2CJ#P9)Fcum^?w
zUqXsWST~gaO;`yhky9@J>*4KQj!l%mlad;M!1?-vhrLDlznJqz>`EsBr>g*I(VdA^
z#j%cq*xBY_yIlirA^&@l{O<*m-Mn#KtxBN|sIN@&@9d6?uyEw^zpq#Rcf-XaMftxB
zOU=nx={Ar`x!9lNe|x3uk%5r^y-3<=N&a6-8b=9^CK~TZ@_zwkFNZhoiQ+0FyLh{r
z5*9(JE8tFL`9BrzjRu}$q`V!voCL=<VxJ26zYTdkn&f|PQT}gC^8YeyMH_(P8f;|S
zu?wA35q|fZo(AM^0>WFc<(xmL{2#<ZbR6q;EB^<`btRT!<$r&Y|GU7c_OKsp8-e<D
zN&XMOztvbq>#^x=#6ol(^?NlElk5LCCHa4C#q6&k&Bf4VG!ppQB>(p!|4;Mm&DegG
z|0kjIQ+?#$88?%$cfAU`(xX@v-%R>Sp<MnSMxJlMvULq3Ij_X-@C>>97B;D8k^iTX
z{NJ5)&l>D<Yk2;C@~$TT&yiC%JiD0lMyz3d<^OBggvT=v`k7w&cPHOf)I9b7b5QF;
zym`-%^8eHT`F|U<zk&MnFu17yKau4BO>q9TtOoJt;1lxy2Dl#b|Dj6c!TLBKY*!%1
zAH=@<+tjqb!wUJQ;PP{*^CaUM&e#7V=D0k@n)FXIFa0x=u#2~=nWg?-=Gy<+kn;bH
zUitq9dp9co-vqv2BL8njT5m&c{~^i$^S$!_Zg}u7N&bIGDgXH2^8dfJ{A+#iFZ!FM
zvsbkQ<Aue@9Q@0zJYH1~_AI0P+&-ig%cr%Z&hrmDQTXr&4)%J@sah~z34U!xIsEoR
zs|W1^dOAi=J}hwBZ=!EsJ-rqd@eeq(irIU~EkV`OhhKK|z-)in<F+?x@2qwTT7LNa
zYHKmK@cFA=e%J{u(em_k6(VhImHV{ixoX7`YWp!lVYy-Zvgcbpg!M}cjsECC|5$HZ
zpW^C4yN31#{U^hIWv|daqED&^rQ8;RrO7*UinI2e>Osqawt(Qj{^a^c%76WbtB2sf
zzTLuY+g7WHRu21dwFY68|Ly`U|Fwri-?dr}T9(3}ICcio-&6kU(_2gV!GHJr)bgND
zYtDaL*40Dse{zxkde3U3a9!ov_%FTO<z{M1spTei0@Yu(HvYTvcJSYwMD>xiFEN#;
zweYWzn8APjXXU@M_~rkMA$m<Ey2yWL-Mb2bK6LtJ>fPpS`pT`UQu??G{@Y)k1_k85
z_J#TVqYZLDC-L8&t6qf7q#FkX<-cvh>Y<rlyq<hZXp8HA-O63m{{^&ftA{Qq)kvFc
zHuRoL9^Jq_T>dX7?fS(3ndG!O^>RAtS=G+}g-P00(&`NUd)@#{)kAmU|H5P+a4+wi
z|K0F^P4(oo8TGr|1=Y6|`F}j^vAML<cG6d<HLQmIOX*=uB&V&(>am@xGipeFCR|!U
z|7J%S|9A4tK4dLk9`awWr%UJ?2LI232YSR@P&5BGC;p!S)~-G|t*{;WI}U2Nwp_Jv
zGE#bVk^h^hGl%fPID+Kwq2+x-wZy#7(6r|vE4!h9{68PK>(jY5{<|KQez*sq{f;vJ
zUk(3ns-b+nz4kNCe?Fu1dS1<;N94M0C(-V&o&T?<CBKyR{FV6jypgNRq2XJG#s3HC
zKSlk&8b6ZZ@c)h?|DVGf>Hzg${$B<EKSAH3dbo$$|41+Yzf79f(ARlM&HR6sRo1Si
zKW6=R-GD>%ihhV!(C68^@nhAC2j<@@^8YzJK%Pkazm4;^sQ<2wRxSJtYTW_<e~iDz
z7ohwbSb0qSe>J_s|K@)+>g9coQoM}I=uhO&;?C#MQ|bHOw|P&+_VU2=rt?dlAGR?g
zH{ayB*?u#B`wV`Q^WYQzY!^F@Yc5en#IW>uYx_C+9FFAW!Ircmu(s=?ZJ+m-@)(}Y
zRlji$Tf(LEw#lPE74vRmM6LARR=3|<+hM}zjKp&I%`@6qj)CU1Dy6rz<s2kiu&&?~
zV{#=39Idm3>lmVTY{x-upXNE3r}&#o%ph|-F@G!M;;$86i<^C$!SHu{&att<@pt6X
zu>)Hrj?b0nANV_d<eZ<ev|XG#R4QM8U-zMRohf0}qpLi<vkj*Z!*uSl(jWg$QsnsC
zwww$;&K}B3a9quj#ouuvXI7QxKY|ofXi1Fc-JBx+6MIvWQEDZY<L_*kJa_kKurD*W
zh`(#6H<M54y(`GOgGf34`D*v(?(W8c|8nr3N_uCxl+w5IWL?7F)#@h`e@-6>4E$rq
ziFT~Y&JeL(ljk7*Yq6+}p$#yFH(SyC<@x9MYmc78ciA=E*Y~Ct!Zwb|`0oPW^?Xx;
z|9ca(<@ldb#Q#LNu!C49L5tJM@(=ts^L<|qY-iF=>5Knvay(MR{{-Ie!;)BD13U5j
z9L;y-B&09L|7ail_h2i#kur1qk78lYsiXYwgD%%Xqf5a52zKb}v746O2mY6l<CPrB
z|KYOS3s`oq;G6h3n7xF&#Q$Etc%}4Df&YHWe?L&TV)RK|KT-DnO<27r@`e2n_&-|s
zI5x)D^x@BL{8f+Ok*weK$MF8_kN=y&|J8l){~c`4<@^u)|DcHfr?Dq~v#k98zwys0
z<vFhNCp@Sr<SDf>MINC=Ys)9TD%zyNE|vfKt*Ir1ea4tkdf3&x?*APdJU4sy0kvA%
zEA_A6srcdzo~raT>>7@Zi$Qo{nc6!c$f;UN(f7)4h2JG@QsI?h=~{N;TiQ4Fz&qj9
zsub`Fjs6YsEw05z<(D_U%3|*q%(GDWWvXsr(#s}n9DY5FAK%yTRjZyp=x=#`2Q69K
zfId&+Qa!!CQQ8-T)^C$G!k~iRYI!?!@Vi~|?XhR=$_x50g|)0Y|D5YD|FyD7G3|Y>
zL7=6^Fmyc#4<EnTdLK!BSI87^+YHr%v2B@XP0JzIW6G5f+)=Aq&|}Ay52F6ae@k_|
z&^)Ts-}&S1e53S!v9IV%axG+9>in%1Y_r6CX<Gonf9*`ph#vuL)q?FEXa5=3RVw`o
zxn6->=^&44L2n#=h?E;43I6N9(3<k9#y@wPbB>z)p9%)@e=^jN|5Bn_`r!W*a?$%n
z{yP`U7L;B+)q`sVIM=s}U)Rc1a@_~RJ)LUf|NJ8VEpy6?<o_ZtUPQ^=iU0G`Rc-vY
z#Wk1jr!uz$O3s9ei@{|f*pDF3YQepCrqZU8|Eu8tbiU)k|2Z}BUvHEpiT`ss2miZh
z@#&E<6TVjC-z5AO)?rf{LF;8I5V$XT@P9FoROf#;6nBJwE8N=(Eo=!-BS-z0YMBM7
z_lq-D<o}Ld{;$Ngvmw!=8vQm>`jP~v{NGXJ|3<FY(ym-qEjiGx#SY{8@8>11ujh&U
zKb!MXj%p$Je<oOrrv<n>@&96QxiInnqH4*ZQi=ap!T&w96NCTf)8?$~7m{bZ7H^FH
z{J($}U+w&VS>pdTT82|ecX{Ifnbd#ze=5Zct^afWzY_kxl9B%_z(D?A4raIIKn`)9
zh{wQXSZS^)^8Xz0xdM4Oq0j^W&m1CUy!tKpua`#wn^b}E^$Vy21xDA0$N#6`|5IT4
zDr83fU&y{J<FV5nBA=ndRMy0t%eegtJO+aQuVCkgmof%#{eN!g#Jugx|LaNjjUxX)
z%RHlZS53c`6waGF1{Cjv62~~cn)v@tWbrQ256!=OnSb;Y*nYg1|L>yye<kt%u^RaQ
z7&Y$w)c^m$9wz_)3cK7p;s0NP*}ucXYT^GF{(mGZ^xR$K#UDVGTr}8#sOP#NsPr)D
z9_9EBX}`<)cR9a{_;WZvPTEg!?fDVTR@Z;v`eKel#j<!bFl4+;J%!1$=FVR@@O{~n
zuM+ilDEFP5zrpzrINrteA9B2h>u+(qm+L>~cpul#bN&;K$GCo+^9MP<z;QmuOMwfc
zYmbWI;~YQc`qJV%&vzE@#YH@fKZ88P)q8Q8QjEWcGX~(4*DJXuo_VpENyMd$o-27~
zo}N8?c1Ju*Wxs;>Kjc}loSt*J_P8L9R4)0Yw6~Lv^3AW%!?`MriTD3XNUd@h=vh9}
z;^vor(+Hl`)!BK?xQna05p)lHH(_G?q>j!hQ>RUzF|%v-oO#^~iokuA#BT+kFLJz%
z>o0NsGRHeOzQ!?zXX80u0BvYqcstM9Id+m>UYx))Xqf2f^HVuAAjpT0av-ZoHjVRg
z;wroFU70mb&&eF7F|B-%ua;BfGqGw6St1Pd0Dt=OVl9nE)Q!kEMvZA1JFa!SP4qsY
z=i`+1Cd&LY$LF~I0_WFph{JDl7Pk9&{tU2vm;-!$m!5CrdK>ScO`?HxdK>SQap@+_
zZsBZwf1cxITob2fFW18iiQAwiegu#MyKF>5Q}fWHxIKRa44>!tQ<8p~^BRud=Rn3a
zN%ef7w(Ft66&RoyF`~YHBrugl?)fM%e~RO`!23Q9q%_eG+9kR{8)?<&`R=j|yhN-C
zh;lZdL)i08-hYQYKFRruflI>a&0LGyU}u}_<)N;wzP_QMv2nz}{0qMaY|jC!e0?L=
zInRqc74AY4N6zD$h;wr>K5{Tvu)e~=5eYGkCPRg9QSP@n;9KEyMSLC_<ec+Ue0^WM
zADA_Tr_x6f8XD@VmH#a9-@pNmN!F3$R5yzEWwH#1sC4!HN;Ljwc&4lgmxnT#Uzd1M
zS6|oASl>VWla%`u<$s9tGn`+|`2gu(!}V*qzKrXC<+zqI{*&XMxqgE4Q=FgXyp8jA
z&O10un|nCAN&805tBdJ<wv=n%^UnP9_vt(RIi8#Umy7R>>p^<UGmbD=euBsJpW`6@
zfb`dshWPpW-uO3=-;Er?Qp87i5<ZkAJSl(SJCQgvjZ^t2a6YYg@T}H=45~-SI91)G
zRH(vyHtH}O8I;Zu@t=&5#vLSpW6xK3{x!~D=kS}nn0vnOscq8Dc_;TPIL_d(Y0i<J
zao^L*eFtadz&OND@698BUmoAKlJUv2hvuzqr=D9mNZ;q)XT|p^zx+NgPngVqko4v7
z36J=sGRQB_E61ldeHlE$mteGf%1cKJ&&F{K6%s$-OC5jKrKINN3E%Mg5ip~kP*-ow
zt*cA57p=wrh<g4jWPCm4ALZSRoR4un#IcBL<@qq@=HmUyTzhce=UEN!2aBJ|DCXCD
zU3TC5tU`I^?|ZL@fUh^sAn^LG&-(`MITF4|bx-l|S;b&|NgpA<arGk`8%8!XH8wPj
z8r3+extXu<n9-wKTE>hSJGNzP>$q{_#*c4poiK6ygo$nZ7c&0g;$UGq^;zBV@4)dN
z9J9E$ovQ47p63^FoWQmE^4(n58o+5n`{d54vxZL4^K;(+EqPBM!9Q{SHTUY!slf3s
zT>mewZG(4lpx=^SL}#S7G3}9_xg352@8jKku19e_mP37uyru6DZMk%>egYR<VG6i(
zgg*T+am4p49QX3<Yn;^~uj2SR_ut}d9sN^|?{WVW=a+J(J!w0u@Hx)v+b?pqj&r0o
z=U;ICD94X@Mqaqm7kd7R^Z#c7oDIcO?>T?s^ZKUIHcBV9brhTBbLXWr<v(u(ZodP+
z%lQG$@8B%n;`UAs@p?aJ^_28IpEEQ~dX#I-D=ujl^t_X^I>6`fpyz7NwTJrDur|KB
zrU<)r$Zu@P*q0;BGeXZeWa96*_y?|k#X&p2Fqvl^9DeIw&%yUAwTu03xA9*1uH-rG
z2EXB{y^0P?eY5?%LvN?H<M(;?0}kck84lWk(kZpo9^fpkOefCL>MD-kR4Ah9S8-$m
zI$%u8q$z{t{WuTr2ZpzBejA7K3r-2%-CTcwYjrcY=lo0f^A2-jeCOrs9UQOW{w~h9
za|W+OBV`}FdX{ls!SUik9m)9G)brUXWl+Sc^kA^7Ur_enaM<4&4Nq-{f12Yt4scIx
zaOLxIuD{LkM_fP8S$b3t8DGI6L(&=d5#>?xe1vmOv+dlYHyDnOA$OmvXVed`;Jlyn
zkRcUZwR~+ZNq%>5UP*@5wequdgLi#`UwDr6?8p56jAJCUYv8z(YtwAx*ut@g{QT}+
z%yBITbvAvw|A6zGc^?7d6XG|X6n}f`7~hZ7_nyjmF2@XxS>z$ClvRFC?YEnGb{X#?
z04?9W{I2}0K8LoL{30JB^-SYv;l90ePG#ozqauD!DMPZSag)=8*Lmpq30L;7q{VAE
zq>J?VIC+19V=vd|aF+MTK!OFHu;5v=#lOiJIY_#WdT8j|k{yI-5iNfCPW8N-OKAmO
ziEeYbF48U0ZadEp@l5{kyvKWK$~oCIykEp|IS0Y=JyMspM1y$Q@7K0|!X4USludL^
za0tT!o=H>TD&9-?M1S8c<q!_}VL8&B5M|o~rNv*L+fCwK|6jhXSMtq1AKkRAa4J&B
z!kYZ<;W!`JJb_~mb;(5)&+oYyjCTx>_LQYf+tj^a+7EaGM6smRJu7>3$Ddjl*L$AV
zlm5~(Hhklb7(Sx~JuXRBA29tc(F9RMZ5-F77I7Y<n^X?w*Ywwu`Ijdxp3N6k*ffep
zUNR!37F}KO?WsMd(HGgs-|n8RaEndadbanR3?-}?y=eAkx)e=4wPzYUnZ@6t^gF9(
zanH=eP2xkR^2R)av+#~>Ht0q49zIJPH8wgs)tt=lPewsmLrYVAL(}B(9nC8@AGdv{
za8wK_K`Pdi+>NPgsH-2_+&HGLv0?0}5hGd~Tbdi|Cr)UYG<Nj3G2@yWM@<+te!|#s
z?VTN+9qr>MO&BwALg%C<OP8-$wR+9kb?Y~5+_Yuuw&QmcOB5mgM~oOdCL1wwMC0hz
zmc~)7^=)nACp3+28$Eea`^4r+?UUxr?_RKQ(PF=1eS?HUU5?4>>zgUu^i54I05En!
zd*}47*#nwP$n}^pt*!0tlO|2J_1lm&H`_KJKYqf5wzg?A`Ob}L)f%b>OhIj|?E(#F
z-^xB!<EW;_rsh$!>qn0oJ!TAF_pvQ4<Hn60+uAy=b;9`Z<0noexAuu`?UVSQ+`)fm
zr<o;io9jk4)VH*BVP;*pJj$s2n^H)6ExG*pX&BMmkkvO)QARe78OcxcNc$I!&7)gJ
zjv6_pxn*=CqBwf&gh`z?9B0j*zi9E2rOQ^VT(!D?IVpG0t82;{vxZS48%H)bjA|M^
zdi0pa(Ty$kSXxGb#pI4DQ|GEO1Oys1Ha3nTQVXrq0Xage5r`Mvo-w0w1ype-qBS<r
z8yXF%R<13qTwMT`lMf$0c=i6nU3<Ic9cYexmMvR;_`uOC_g#JP$iAx%9X@z$`4vab
zy7Bre&$@E?ksD9jb=J;(`Tf2fC#~9d(Yyou_Rc%D@A&gBSheg**5cf`|HzT+Z|b`8
z#)JEBI@nd1bLhyGhi^V`uxrb)n+_a0a?`SFj>CVl_u--IuH)g2hmNG@Lh#b-4;|>L
zR?-3zZP<6yqOO2t$IVwQ=^F58@4;hBx_TcUK71n&y81p5F%owz?0Q9WVgD7^-+0rZ
zBUh8vK(Z9Ny1Mr5yKdFmb%(lcz3#ddOZ;7#e#tg&xmdZmt1Ade{1iyEa@B@Ii@J^$
z2}gOGiBo)?XWHjI85t#ovUqtupi%^U^Pu^Z-UDuhvVt7GT)w=^+zuW))^+ub*WY}!
z>t%;-x~6Mo*UmGJ34`UAfu6wG+O;4@Yhl;?ULN@F;&}%y1*!q*q<vSUlZK1R)A_Dn
zx)KUz+PAzu?<%IFlz!z^NtYnBw7k3=&LCC1=?iD^S=Uw9-`J%{b{*QfV#&2zS8P7C
zW!{0!hZZkha_!=+tCDaP^0?_-Mo@~q_|T<*dURh2K#JyJFCFu=3LY`{U8fxGyYi(s
z9Xxty!#;jiu3J!+W!J^mUb-+PF7lx){mRPeOT`b79&pP**ni-_v10k9N)bipWqPh1
z?!_x}$jj1O(`o~|l)O-u-tvLFERPoj_tE`VzN8FWDUsLzmA&NdQ|_X~QzDk2KYH-S
z>u$d3;F??3t&wo+)+`9Zt+-{^1~VxKJ4Axyix>0em6fXMs=TW9(HCY^Bi*S(U5mSl
zGE)vf(5)iBdnvG@gnpr4`ZA(dl-FYUU1i)0{ZY)T3i|*f6fs=LwPv66K?gFcSak*w
z{Q-E?njSQ|av>gA{{*%KM_)NCN2C(7SLe*m;j2aWC>VMC0X(h9mOg5vU-~i}hDu+?
z(z5c)1gc`<J~BBZ`~zqhwKA8<vT|zydVnmJrLUEDNeIi*t?+s{veysal{Kd?lfAO?
zYlS<tILgwM@u`~b8@v&*CKuL{{0*-z51#GXVzz_7T{q<0^+UehFyz~f#kaDjQnP7A
z9%pdiR`zLEmC+g=m65w*wJ6oeJgw&eL>(%9S)CjLkKT_;1w4B7P=)ustgrAs=V2u}
z=3K1wKIdbl_c<pkz3=7a;P9=g!pBv;e5{bZ3jMaM$_ZE@eHHqxszSe2Rp_^>3jJ19
zq2H=1^jqCaKV?iyNY8AJ4{-d72aH1%j^ntH;~IOw{em`7ZSsE_@g1|uO*|8`krSF2
zUBxa&q%e>bQ)@vh%$U|VdQ^SWn5IUI0;8K7o10r2n?{epXb`c+jHWY8X1Ku+_{9>y
zOH6I?ek9|#g9JwwiPzNJ&^C%f3r&swVhpIOn>4w3<jAp&E%dlsM~xZVntWB7$h^ft
zNc-aH511`sksbKD`VkpV`(d6eF{3hUFipnH`n~oUPe-&5{vuxEZHwI!3k5@e8jB*2
zvJ?y>)@38(LGSxwT2CXe0VOx4vS(E<wfAC8OMVX6q?1kCu_DJ9{+WAyBJ`_xHOG^K
zqE)qsp&}%kYAZ3iIkcy0PyQI!Uyf8g6xrj~4I6M8Z-~eFFZMueqF6|=q3%gm(*1=i
z)0kx*W5_e5C(CHhJZ#I@cPOm^o2Ibj0hp5Adk=3NCvc45PL4NoXcxy;p8S)3%$ae9
zVF&Ar)-r@E*|!}R5Z9ZzzlX!Ig|g6NeZ&r(Z2pc5Bui*ngua(7YuK|jSxt9hTRssx
z>dDaRw7!wb?zEoHEX=}Qx`>eq?Wt-2ZKE#g+AkoaLxz6Q2i(4@N*FTp8eR@4aF`FO
zfLHZ(NQ0^-Ir;D#^ZxXnbie>hJ#%6lIEY!-S}Bba@kgd>Mc;Wl&UGEjZ|uJq@na62
zYX&(Zs}w)>0CTS+<2!I!UznNVs7Tw0TPVyLB>q`E?<gGLcY6U*XP$%cmlWpldvY4^
z*i;antJ2#=%q%uOgJs13How!823t}%m+OfC!4&_W*+C<;r*W?0`V9rE_+K;IwNQ8{
zJvlA&N#7t|szJ|#U!@lnf1Gt%qN!K$L>ku?od0L}RJs(x1uvde&%t?$u54g@XOUU1
zGdV}5JgcYAW5|W_;A#l91WR<ad*^y8E3wL$YauufvwCnfHrJ7Nbpj!GrFmDpb`GL)
zP(8%VL+9{0=gpN8oO!9#3tP1y$NKVLe#Em{(u=t(ESSm~<GoMvdRVP|*OL%$=a5>v
zoQ3LqSoc%v&y&IOa)oo(mlxt#r{3A1u67W0cCa+%&(sX+iT-6d53rWt`flzU?8*<W
zBH^q%_XZom)wmimXe;vHb-IK9&b|!(Pp%=o`&ib4t?QAy->a*650C#*Tco}Glk!qi
z9yZocelGd)-<hDne^ci3uZPa08M-O!@?Uxd|HnbSTKVt(%F;iB2Ch6SFWsqk5>Kj!
z;Qv&p);H7@=Jb6~;ZFX$Z|wXc|DAnU&+N%s`M->YiS^%|T<Z#5TrUOknTaMVE0kIO
zcq#KA>uK1y9(PA!F>}t=L4k$j>MpO<gVa)MNOyOHb*}(9sUE4F|H`_loCj@Q6Dio0
z`l<){-vz(i&(`?v`P>2RW6-;L`URv2{!fShOGz30cg48r)sv?$Zh@4pdtDxC=l}Y|
z|GlgTwS^g^XBT$Dk8{&3*v;h`R=B=`H8Yyw;pvJ0=alh(Q=xYLySDOC+(@p5|2G!-
zf08aFRfGFhy8pAgR8J%2bmZ5S`CW~sHvUgXTF29zuPe-kYdQZr$fFkiuVU_97u}1T
z|Hrc~-1fx(Wrcx*=>yTZoG!^u%H9p+XT!~lf%`bhz8ojJ+W5blw0-%%n__C^|HZ6+
z(gW@H;vARr{}T9rH#Di8|BujCdjn<W{J)#J_+H)rs)k2X{r@5Ect59=cr|N`$^Z9I
z|A)(eSKi6_zbWy*yK3pu>GZ;xMgH$i{CE9%_fe>o|F28@KM1$R(b|>&_Z5zj)9tzm
zRt<lY_<tj-xxEn=TKRt~E{d-k7XM#>|BqAu?n_R<(G`{d_f;*uKzZA;6<Jrdw{T+i
zOB|7{|6{V?zb*1=p|fxzm|Oo`bv)?5gB9Jaf3?#8Y3A<U4JU&BZ)N@YW4O)MM*rsv
zi?S|ey_V?z<HCyU7&|f6M*mKX2oJHt<y(RO2dq{15IaqN0r=m_^<&kL=lvH7Em^?-
zg+B0a$o{M*{b3P#?<K#A_H60b=jHF>y7az(`cj^i<CMQC<!?DJCggo3)7$#;-Xrf%
z#gk~O$Gf<;tVnD7H(Kp^N+FCq0>Ajp=@5D6>2tXAv(IY_w)%5OqrAW%`U0*YQtAb{
zVzz$~-#5{7iyZ8++vCV#j`EEaJ&Wj%TZZYPlstD+290Wix)jU2%+tQ3eE{<*ts+!v
z!`dFUM`y{#vyT!fd?TI#k#F)VTS8%#h%$sSuI#l6uj%YHTB^AkfB3=gba~3?`2;V0
z*FOYDT=j2Ykoti`#PUwu3}Wo+K(3{&tVPIkF;*V4_^O7J{S8-3a%VMjwGSahU18Z3
zq2!Hpj@{#eqV`ObX59)6!L#6yZ_Lrv1Y<=*v59@#Vr3(_WB*)=Tb>+=)yQk@^OvI~
z_e>pp6%%vxY`MbkwXJC_OulusCj0z89g`riuPapIEWWN{=sJn6KoqMgdN#c{`R9s>
z_V`_WNSTs$vHDUuY_(iVW!Ds!z9Tuiy0~S#rl6~yyUMojd}6Hn)WWlWEk^d<Z6}JE
zJ#lM=>w=4i>n6KOwsr{R-JN};QWH<Lj#=N8S}CFw*#GzW@Pkq*{UT54sC0xr34If?
zsl<jB^l8M2SiZ^Ab4l>Izj?gSFvf~2Q+wr~@$$G_yoeCBH?)~jFDyQjp3$SW?nTY;
zN<Ks_@!H^B*uvt8&?$eWlImg}S}Jr{<Q;UgT(5jK+#uhCAnIhmBIjL=Oen1x2C;FC
zCl6z}(v_B~h^y>b%eA?M9ZiU%R~q_XtC%%L$yeT`i>pmZ2TNB{qjYYE5tLc$Rao9)
z^-^td%B?aUHaKgWt9lt*ITnV1SZKvj`bmjcl|HVlC1RcHBPHK@WxWoYl{H12wEdW?
z@rNJ!>wj%f)+@DRD@SO_Qod2kTyHBv`FkygAqOQ{2-%PyN_*&k@rV%mKP>He%;KvW
zPTI}1_PAb{dkVBegIEWwnX~KFYt_?6;rjjV<!8yUp6NKOU18_c{uBD&SdHWu`hOzn
zMst_ze^)D0k4>aJEqpE9Yds77Kh!>kl~9RY9^1*m9Lx2;+Ai1su78^A|H)j}r!}g?
zqK>Ov|F;5-ximoqb+9`%v?t6wo8H|GnL@z3Htrp*=mfX%Ja3@K)yDO3Lnm~Ly$Rgm
zQ2p;tgqH8R|HA5ua*gSU`hOz570b5A?66u%|4${RtI$oO=i!>KllXHd!zpmf9-%uY
zy0UB&PhHziPFZ)=|82zW;LeF4!wuF*@%9^PZL|)Wv)5`DrN{U26;dxoom5_Yt5ipO
z%$&SZ{>>wDRtrTeOHc>Nuh7NT2Ib%UBQGw770go^_N+GZJF5hQu2aj{77zw?r7%01
zrN)s%YS7T8@kZUQhE+@Y{dP}Q&qAzj6V7OR*lLM!vDmjYbU<w*4nmv<*B^}iOroVA
zH>HVE<O+!H(khSL7ts2Z>woLLyIzLH)*9P_q+377gQZkZ-zX(fKi%ilIxZgS3hj;7
z-~X!qcTa!}InVWf2l-A()(iFjWZ*G0@+|cK1Zsj>N}1M1-40yVXDK@h2-}fv;j80H
z*>_z%wS&8<s{h>~H1vNfXRZDdQ`vRYCR4na;KYscv4ZjBS<?UR2wMshxOAM71!{mc
zg7r8Lq5mgwThjmS#g`+2(4ASQ0P%Fnn82SFTZ8&v+6*_8>;G;jyBHdT{_o;E2b<y?
zN@(CW*Z;HN*8*a>m#O-H7A1EOcVyz?0)CaI89>wljB|MJ4i;KgI!UMgpTqOHP~Y-G
z|I6Jbp4T?!SB|6mTDZq;J$d)l|J^(**Z=c@yNhyHA`3J4UCOBM7&Kn!|0!Ix^445(
z{qL?H?b!B5GP>YCgs!tV4cq=g=+VY~8?je|*J7S`f$g#+h2_vyzYhJsnDlF~9ZUa-
z<nL~r8EeU{1=i7&9s1u`>VH?$-pDw^RPYG>KNE;H5_2UmZ9+cQBV%hw+X?hjfNl<N
z8hNAspU+d=9(Xzv%nIPJfK-lNyg2=DKgil=>rpKdI|QkvZBeO}#_~SzN2w3hx9U<g
zs;vR{QjXQ(L;u^?vIXn9tiE$)TVtusY>D{&b)-a@A4g2{R!10XxFPhv`p2D_LjPNi
z`w6T2+<(|FuzGePkhlhV=>N%J;@YojlLp@VCiK619re}!)>ZYCaN5df;NJa@)C_7W
zwUgn+>VHR@{QkSYax+)z|C!v)MqX#bUG@JAAXM62UDdsm=M!flb<;INnLNo`pEal2
zI)&8k53T<1K<eswXPs3OOeIHc#p?fAyitZ6y=YANCNzfevzFX5<b5_}&nAyt|E~iZ
z_5Xa}Eg-+^C}APbCLqZRIn@74NzqR2DCz$tyjhFPtN&M$KJ@=epp?RM!LD5YyEeX5
zi1z>blwug57o*N))Tz*CtihE-3ups*x&}y>7Gvtrq{iNv?vI0}5&G-@xj;J?nCBMX
z=UROs*mhIeabQ@||Ca7l-EL^4BiHak=>M(hn|U@ea6W5>Zh>;k3#V~b|DTEbRRh1r
z!6)1Qq5s|eCiMU5NcAq_s{dD^OLoG=ajXiz7G9S0|5_kc|I61ilPoR6R^P(C?TZuP
zZWGV{EBgNucwXNAznHtw|C^xtDR5f-e*s+1_5bCC?MT<D@Xiry_5TGx82W!3&)moK
z<icfOHlIn%>i+}8x|Bcl|3w^^Ah~<crUw`~>R{bb>-X?NCnGMd_}j%8)+$Q78Y(Qr
z2~hoiEb0G~`sn{Nq2m!Kb~BVa9~gGQokm7M8hE1qKdbQ4LG=GV-t0vGpNaHb!RXl4
zxZfQn)$#D{0Du1#{jW|DZ+j5#Nmj>iwExxr?wH};4DJuFrORGsD;S6V_pO@UUC-@>
zxUae%6ea!d_s-ssv1ahbQDwh&(VkGtsWU7;@){oXbxZ8vZ!+gx|GNuC7ZS6OL;c@H
z=?jyt6N7og4gK%#)U&8}?n^d<7%lM0z2QcH!35w6kCJHrFXoB*-(H(*9M7Nzw-Vnr
zl4HH0|2udy+z{>mT>l@345|N@Q`$-7dJ6J!3h=B#Bh5gXb^-k^p0`oU&mhi3Mh}-G
zK|51hqm^f?lK$TT{MP98z`Y#`xQF>fG(sm@Z6`Up_g5X-W)^SMZtb)t)Wfz1hZojT
z=Q8%L2>rhe`E?xaEMz?N|79-DfTXSij$HrmN19JTl9wX?rz6Xu|2H7b2axNvNci!{
z`bscW|DVj&7UG2d-;=&vyU4v2im3ljMVjoXy*T~98}6%tUtNZ_`hRx?{eKbhcBZ(m
z1%e1ya&pYuVEg|t(9VV0htrd^L_@l|0XlaV?iy78-^`oaUxfa@1`c1%XyH|b{VaWR
zkd=tl{|6Y)d>`jmz?U-_Q&j)I4L)51%(t?-aSvm&q5m&{1G)ac9_dm4?<2?eG9G*s
znaSJ#Ytc_PkZv8C^fCB77y6t{dF#-j>i^66dyHeaq167brvL8+{(F-Cza7rM1L^rH
zGNt~11pMw~agf%+=YaoO;C>~GRWvXL`#9tJUoKpic22t&9;^SqRMh`pK-w>1cduuY
z{{IxXy*T~<EcNvf>e$cm9Z>&&1@D2MAqTe>_5Ww7S+9bcuTEcyufVG#!1}k0vVRNt
z{}hYmyb90M+mrtP063}tpJo*J37~#+YX3i8_%3zelk6k?75p5oz#}#E|F@|p9|fla
z_&(VFe<gdu4L=Oj|J%?DI+)ugDe3>!JX=C7T#2sO%$t$aXW!~GG#y!61Pqg@z3QeV
zXm$5Y9GCi6>VIRYtJhK6<jp9~8<DS><g|fzq5n%Qty=Lg&)w+C89=ZtwI6c*e<5Bm
zYtZ{=QTm0P_fT3%|F3~7ojkiV>Hjl;b}Mp!8YxzzcXm);PEJ}y{l5v$O`u-n`hPEa
z_9A3&U()}l^y>fJXujcw@xV4FY0If-$&&uR5(&7f@F1{+{=b_zcfsGu9O~(NSZ}+p
z{=bXb_b@g1W_0KdS|D#I)Bm?oH?Cv}tV6x}Uw?<t|E~n((EnE<Ny81f{{L<C%WUNK
zbNJ8f<@bl^9^3zanDqZQSR?#H)Y;M0)0M0czLKdMPokI9|K9~4zq*ej&40q)=xYnl
zQ)@R-i^}!?YoYa9@Qc_(ZMl&*ub{rpz(?Y3)C=|hjcA|uP~vdIZfejsNi;Dt<$Wpn
zm#Akiun)WbL$?1vou2yhQ6RoA`H|CJ%5wexPrS+X|L<`9?_gW5{~t9eA<NvMsXep(
z|0LXdFL@VI=}x8iILqb@zy05lO<*~-6SAvVKu!I>FDvQ)UqYqli~9dR@vjN}zc3qx
z$IbTad1~kHv$T@>|JUpo|1o6duh5_Wgj`R~_Gaq;FH$rAIJGF&7UpF);MtPv|387l
zq5sEZpJEbDYu1`Q#&1G&7(Z(8$?1!F9=d%W^|1~P52k<gX*!%*14onoIRR<ztAB2y
zMZFezy9NDoQqn(X4yk``1%sLB(p!E*`sZELpR3UG^O4O7d{@*zH&oC+Z^7^FR^<Fr
zWcoGe6ZOw$lm59s>7S<yA4vM=5a0C&*(>x$zA@^bTd4UZ{d0)>&_9Q${g1y0{qqb9
zJU)TsX@9sFo<7f4?2~+%Mr5IXe#|1>wm-YGBS^rSY;s{urv6!wJzV$*f6@N@AGDa%
zKgVUc{u!5r{`oL^@^gjTsQn|dEm`QFU+}%S8|nXEYJX18-i_@25oKP*`g6k&ofLID
zT5U3N+Qa@GFCagEp5*5}$jW2XvB%J&uje~@KUDiCmIwPK^79OG{Yl<@3HkBulTh{{
zzQZ46KhN(1iSqLV8ekzUsBa-ZdS^wfhuKT*_sYIsx1tH&mE`9UV2Qkj3xEFo`XO2)
z<Y#C0(}K10StimAl%Jmf<Jahoy`^wwwlPzFHf74sUjx^xveT%^_d~@xe8LW8UxyY8
zvsu|iSxJ62WcL&%WPZO2*-ZGcA#2Xs3x7(yuIzE%3>SVAM4}iOio3Xucctg0d!Oac
zEiunwVClxv3XuPWpMmk~(&4Y^J?C-aZT=>IZ!QCa7C&P;ijiMyhlm_wWGZ|ZqQuB8
za?(@4v?DltV!ZyLK0Syx#xs_qQ4L%<E*2IJt#ILMkfNmL0g*lu!WFn_tLq!g$5F(<
zATV(R&tRH7cxCFKO1zIJd5nNAzst|Le}*0@?hUHVH>^C`Ivq9Bzak*aNA?_h6CX?S
zjiY>8mmS#}7|cgM9Oo-&GY+b1&()?BTydP=a<mx7D0+CA1*Yy>W=gF`{exq6{y8q}
zUyN^>hyD(Ze}zR`n}F|P29OqM<C>p-0Aqnet8YvH?0GInLkfc0{z`c{8$1ol1~=qq
z?)T#Jk_6@X^erNC%K0DEi5!BymY{@qSBho6K_^p$mxsI>7{Z4n(&nR~`db8FLt5p6
zX)Pmo9y#Tsw^Gh0gUNr4hdF-W_^JHYH$-lmQ@Q->D`G7Fe6CNyXpWG7VQ^fbf6zx>
zo0PK)l@ZU5PWV)r^=wee97zp$LJs9?DGbcpcS?@G?Wug0;3Mylf33RCnvv3ubZA|T
zk!|JQ(Md;e9g}b$Gv(h=&w;^l-IDxkT{Bh4zojbI%D=XJM@T0Cjd7w3EjFF$jkd1A
z<lp#O=o|wvRUPe!k)%-mwRbu8Czag!)+g2_cgu}&WOJ8JG3qhUzd#C`Q;hhFoe<~p
zALHn`{7a`?{)5ZbSa}vP^fc%n%t_4={!!LNB|f~SOzY^obw4zqxmr_0{?!(y2>I6{
zJ1~EDx>I_D%xj@>gj~KVTk0F-P&^&uauIj$9H$Wu(>iYElfmTQ(QI>(`|h*nY}6_I
zHSpZg`&QD*Vax7FvD(R1`Pb*Alf#_^C!{j;f$1MYDnkCJ(JoW|r;|g-zvI|3I^jH_
zkbh+`A9D`*52+kOjDbP<cid|+7|x(&tA)6UC+<hgLJK_Ak40a3$9kNN>j;$=_YUaP
zK|5>;IcOiAQ9=IQajqo)i|HFVMyvcgI;1pd9aa99&`!_g-!hE3jQm%pH#2~7Ab%Ht
zmGZwCI%*3Z$+3ofRzRaVdYQ9<aT%Cs>6nwAj7--Pun&x+7pILem;brM?;k?`)oIG4
zvLM9Dq>>l%uNHHh*HKcXQ6Ch&kd(`@#LMMhOMCy|tW3xMluk9A5;~6ScH$~SA^)x9
zuQt*mpy!Z&QQ>W13MI@jSpB~Ghi-V|&Xvk$H*sy-PbFW+MU{WGg7Po7$3P9o^1O4_
z-3VgNBmOjED*ukC_79F=>oL(ppTC2{9`!o@8hAbtt57Rk>*7ya`kE9=`JYMt%jk6|
z|M~}n{5x*mKa3-<sKF}>+kr*-KfWmc%jlKl^1qBcR&lqS_$B#wzeCo^=McMr)G@yD
zznq?BMo&v?^K{@;{*NckUY_ovuX!T!wUfJ(!D}b<7|Hc6O7Fm4q5PlBv%%$m4ZYrr
z$t7?9EM~mwtfKs%2c0vlV>7U99S4ms2a1sYUBt=d|BNL6=M!rmrS}g9=o@U~&lz&3
zL+9f;juP`QaEAP!gT-_Uyg!?#J{gInNd3Q@xXS;z(0437(`L#aDF136zwGwnJAtkv
z=_}=5FSbcM9gmbK|9Y*B;a3Tr3Wt^dHuBexMm^=XS^4T4Ow~p$&5#r2e^!#qlKfAh
zq*+)knkabzaYFv*5-a3?Ht+Q$3HetR`-W~tPn7@d^q<Z|KAnZQ6B!BlUjXIwv{=pk
z0{9;CznZu+kfy~+{<kDfFHG{kuy5wv?Lp2rz_%uPn`e>#268#VUjuer<$pK1T)^Me
zz<C%b4#A~uQ0F{)!>dSr1~#2~B(Di6yLJ%yKOf6+$p5XRzJwB6u!^bw_fUfz$G9@V
z^iq0!FXt-ce}8&5iYF!cKW9++zZ>2kN%DUoJ$B{)<{}2i1N8^7UcNKQ|NU6fwSQm6
z`6j5X{J#lF+k@pIm;dVqDWSjo-;cfi6TR~PO8EY6X#E%#HRb=a$jZx+n_a}o<^T66
z@h!ZWL7#n~{Qm$7ew;ro6<<R3pQR6fls@!fYydCEqW&QL{cEx7y^DPpzl+p-n0&tv
z<gcU5<H7B1*yrv5gWtz;`NAObuSRQx$6Ju}jY!G{csv*QM-g{plK+*|y^w!BmNp_w
z%KtWKIs!^M*HZcK;%{-1uf&?(ALV}+^1l)-q5SVbD#jt9q5qFVGB)z;0?Ku#`;h+=
zfnXJuuy)GY%lq?_{BNe*!R3EHcB}1-P@D;-_hL7`zwp|k{NDm4mSS6ZHBz_$JJk{3
zI!3N<<myhWi|YS30N>qU+>8w0+6#Anu?GrofHTVf=aT%tkF?7F^W^$alK-zV>S5X+
z0LAyPwr-=;FJqHfRrq{S{+}cL$Klg$dA7ahpJBUt2bN#jJK1*ZJ0brMa8~}c<Cf&V
zIm_k$S6FfHgGbGo^8ems_x<r8(pf01&prdR>i>}cf5Qs)<HC&W2-4A%eUMU5%l-xX
zr}BSM_P>z-Q?r|}BGqNT28*st`Tq>{;t$~Mb<Ec5AN*?N@^dSac}tR?L!{UQMb1O2
zLVk8r{&h%gE<dkI@^e$K{9K;o=d%9UlZWziCnHIp<my_iU%!o=_mLz&S213Y%g@{4
z#68H*G3<@+htsRDdbNYqhbi&nMfurZL4Gn8%i3O8nw?pgl`X^WcRveoeGIBTUFgV`
zXUfl<ESH~m7v*Pcc4uK~_DSSt3H0pFLVh~oP~Y%OFMS@sQhBuSe?gD;VeLAZ5d`V;
zKrem12Yr4?{kDGn4mRZF$d~ka5boYz_)GN2@49JBzpydG1^_J5=bOyse5SA$m>*#)
zkv~KOKa7M}zdEuDvZicz_BTL3E4vDd+dmf0&AwAOJG+thFU#uDEt{d-FZ$))_g3WM
zi2ii^hP9w{Z5r<ekfLv9y?6G3j9r(W<ac>*-MoC`^LS^pc#;xS`N=If+7S%(9J$RZ
zJ>Ypj>aRVSfF*w#aVr1XzY-d)KjtmGUYp)GVI%N9tXIbJ%2swQ!5*Q(_OTH9g$U|~
zWz814G0f8(EmKVGN7fSTVFu+*t+hhy$;k9Hhfo@76Nn%#w&#PM)ylAaueZEj=k_te
zk`Vn2^YJja?|WdTx4Z5Cz&pJh;zuimG<D4rDQ^G7K8Y5ku(?SSdo@~TguuBV+Iw>B
zhR8g<D#@CXDAxAJyv}LheLRVtkg@W2)pA!Z!mbc`E8|LGaMXN5Uc&N`+rWe==f}_`
zn47ji57XGkQ#Q0Y7=kvQgL-mW+@x47LB8ekuiZ-PlJc*F<nnLNQSRHP*J2s+AC|0Y
zWi-;dh<<6<IhB8H7a@V#t&9=2F)^}78MA#tuBzp)Wh|_s+C`ifq}P@5ub;1L3#l)h
zp_J3x-Oa_OHu)b%8%m0fCru~q^fvC~gzcXZd>!?|HI(GP0|+`P)4pK!FrM~T$p4f?
zaZ^vHtX%%hMbF4q@>KpO@!pw2d7q_P31OL)>QW_YrCipwtWC?{y)va7NEKtL_i72&
zMX4QiOWG*0F*{a!ddR<)GOdwHn9^0d{Evaoqrf@jU(175TxY&$tI#SFx*_C$B4s<n
z%)WGO@+tkD=b}euCpjzs^0<SXow4FdP?MAVPoX@o^u!y>+pu9(qfsYqXXW31qV|uF
z|7rABL;vUUug9RXHo7Riop!CWt!fEc#^$7y<LHMj1hNItU@DYR{%1i2{VMgQQT{EV
z8;rVusy6r+k|yL|@9j3)v?2f6C8pE%Y30zK*jN5nLsP9<)x&sN=gNOKdCUZpa`|5X
zoZ3w0(3h|;Ilqtm+w-X&Lc8ga?<h@-07&zZz@I@OgSIf`UyY-!%vi&df7hx~A804a
z<zN5*c5-%AF(ux0d6a)=-RSe5>!Soh#UJJ0H3PMJN{Mp$*DmLrmv+w1*weP*I!LZQ
zH5~b$K^c1auLU~ge+BTm7S%-hiy{9Dfj|%E)kxSfTDD_(Tbulp<bNp;PDm|ytu@n<
zOgjHX{XZ8@hy3pXj*UtFw^yV|`HK<sjB@!u9q2aEpI$-wbw&AKkNobU1>KFD7VwA&
z`9F<*U2X8^@_zz-+|z;WiX{JQ=+%uS*IfS3KsuxSvldI$iS#CGmH*S}Bkbsv|9wgR
zFC>S0dJYGm$`N|@`;z=0qwL*aGXV_GqLkX?e;SbZRaO3#6TepaJp291xH8O4PyE8E
zJDcFN@*g&_6k&)T_5XBaBIJJ&sU5@7Ls|dlrO5vRu4eFbIY%!4uJ1N|h+Iprl>Zap
z)(PZX!1}Wpjj$Z483l*8aD6J=-paWo|EFOO(rapUDU%_t#$%yS{x5=}Yw7uKqnvA?
zeFq$#2nUq^GwE5)C!X@ZA6&17Ka1ghEkXG=<`igAF8>GUEp|hjS0wpAOqmzacP}8T
z%Kw#=xxJR`f$nMYP_JK&d@iJS{X~-gd$E{|qlda433_Kg`M(%k&%iUNmhfimd+Pru
zi}L?<?v9e<H}DhPgNIrx$DMekybF$AL%fjxZ^7%@^uO}|9Cnp%Ab$W0*nL>O{uuh+
zMxH-F{(p*XY#*h+pPsMsfA6s6e>S=JRa}D1FM=LjNPBm${C9CL*VPaD)VmtsCU`Qh
zM)^_xPX|{mx2xgdh9v)bNR{OO!X*FukkZYRKY{vw3e-Bi7V;A>m;Vc>^{3(qbmt)Q
ze`k{aLr7}}ynO)qzoJI?mH&H-^8YBZ^fVTrYw!)e2j3$7m6iX`!jZROJ5v7t7@Ne^
z@TOMz{{R-8AA#uyv8!d+WS-;tL2~+a;XknJe1a`IAAsu0|1S!E$GcrvSH6a?)Ntkh
zLqPQ(SnqaZmt=p5{=XML$8mTS{j4bedN6+o%6|w>kIrhB|4X1`7u+n#&*eq=IRgva
zOx|^2>k0X}7EDeB6XoY%jr1Qy%+rBZ`MDqJC_lHslc%tvPr%N3JtbdA9lQcAtirCe
z9(&$<hbccl0sfy*f6ro#;l<hP>|5~m1AX+T^79@nq#uDJr(ttkgZ;2J{rLkRdpEW!
z>GRf9zb;1?JVyQc!$hBV7wPjD82+M+K0l$XT0%~rUqPR<v*)nC)fKj66Ef-ZeBt!$
zdi>rm#P4r*_Nr`E;o?mCT#;G7TC!U54?CAp<H|H~S4!;{H0%Z14B{@29d-ks*>}?V
zqy@mM2w_{W7Z&z`uu;W21QElWYzv0%%2?Vs!eV3($KJ4qZyZfEw)XsJKRQzH4E}rt
z0$U;W$ZW|Oge>N#*ai@@fHgno_?x?V`P|auI`0n#{`MfFpBGj(q7l!wZIq>z!ail#
zXnY%eeb-nO|7d-ObwocWgDG<S^+V~8zcbcdCqw)l6&6=Vo9&w!gwye6=L$Ll)mEMO
z+fz5#_jgXeE0o0eusGW8AMfiFH@GI<?TKg~)7ofHEyrIgo&5rBRNC0=?*`8L!f2J!
zqG2ypOM&?3ttV%P<@k5-#?_u3=Plvyh@q`ASB(|_@V~IdV6dINh*UGl$5!`D+7t8n
zp5*xJ*|35qIsVq#zW6Ui6Rqc)5%|w2bP;1I$8rwg2(N&kyIv1t!BXo;34eRX&cJgt
zHG{4rxN@BlL*Q?Jvl%D?|EWCfPH!D;U&Eavt98IQhum%H>tQh~#aIe#&WS6aHFt6~
zpVm)fN?nfsCiH3tG0q47GtiEw^y0q<t#*L#uJ|7hFRmu1jZk2BFaO2=STFt;QT`V2
z-@+UsLkWLZIGF@wWBGcx(ur-V;C~7K<>0>re3tdWe+`hY;_nP}+(P*8d`#PR2Jznv
z{^x=JS>S(S!v7rNU6|hAT*QAj-}Tpn{}IN(&g_T(owSX_|F`)%zl@g9UcLY?Da!w|
zXzT-gn>%O)ivPFx{=A2_<?iBGRUNqgZo>byj0a`t%(v5`dX%Gt{}P~aWf*4wi~nY*
zv$_}m6+8+4p9mFKra7z2Xmbbu&!)`R@a0+s{0{@W_`d}FUq(B^@V<Wd{~q|?Ne|{7
zeB})zv-ONtO$Ocx*;Gbt{%__Hi2r>>`Tsuhe<xq{e`AbpN478P&fd?rX)kd<m(uH1
zaF|ke;6HG6g8vLCaT^%t{1g7GxNm}T!v867yO)u_V=2Ax&&`B?c6J=T%3ouIYIL@k
z83=3;PxvPJ|C0Q_K>k0Y-7^g?zXD(BJpV6J`^xkGRm%U2EYCmxPQ>>mWeFF`?-Cdl
ze?lYYxu_pZn}^a>{-pmozAEZ7?M<fl2pu0I4*gT~y$}0g$yTm*F||5Uy;&{TYx4_~
zf78_ZS^yoT$iG3xs1)o^hNksbt*fV>{vB%KcvC5@&n-*Kj^0*kZ$~p+1x)YW+VHnL
zW9tJJ-?13o&{wy*jXJ)n!8Pe0-&g5b+X#axbHBylUvN^*RBB}qsX_=!#rG_})$-r3
znO_MllS2nbAEdX?`eoNLV0%PbgxBNH>4X2;*P=~hYQ0N?|J7}@<@^s1GQXdG-StQt
z4*$oYBlS(Qj}-iGDYgNI!a$EU+ZU73N5OyfyKN5nU)_cz#gswYPL35t`yxElYq7Aq
zR%GyBsw?xs3tK7p4-5r*dYALxwowat#maSBA+>r|=f7>5;J@o2**0-BVmvf-<)zTE
zLjlp0T02_H^*)|LTK%PL30eQE+kl*(Vl3zFk0!O&?co1pv~u<I(%#mI^FdcZzZHBB
z<^Oyr*<BO=UGE|IuO+LCG*kIq!!aEG$2xd&()QI@(z+r+)Q+L(=eJicT{V|$th8~~
zvM>K?<G<@4)RSf|M*~p1uFKSvehxWQ3$8+<H6(*>?R-5O;oj=R|Fz_*b$;m3m;cAn
zwpdCITN3~0(qgF=W?&IGnMgZ|{6B|Mk1ObDDgS*lbjbO?Iq`oj{NG>X{}w!&P8d2d
zZ}rIw{+~xX>maS4@w7rOf&Z64&vUD$cXcSeHK!5Vu}b?g@_#yiYNBevw*GjeK7(rG
z;Da-ubN<hwFHkM4q#XIbHt~NM?W~ia-&ESt>uFQ2td^XXZqEOM<Z}p1$A$3!WFWte
zT(7N~{wyTT{#GY5#V*3HEBOB!sN(tr)%pKYY>g*lyLb@4zbmnZJOSO`MjQ4p{J$gl
zT@4LF&i_a7u+b-N1?|qL|L=qUPY#`!w_m|h68!%|`2XjL|KDPsaPa?|RnxCW%S=k`
z(xr+2YkK)_3%WZ0&!fG0e3Ad#;QuA`ZnmcS?=1PfRm;C4@&6oVM_T`HhyM@I`h5vj
z*1K!s|HJVAWt4jZ9!VwsKZ||vIxM$;R<-=I=&Rg^Md$-%{C|cX!vl%`e_S>F{4Dr?
zN;WSm=l`?}&$Mh$RxN||^a_Ih*CnsTo66{aHgZ)hoQEYY=zj-T+*PFi^+<JX^q-Y|
z8oK=&uRZBMBl|g+FUv+}(*JL;rdA6dPw?CC2>5>u_tYN`AqC&YyRcfAlpSFgxSyjx
zj;Hq&@c&0)c_#cnsvtk5-o`-kMi0bN?M0OCN^sb!i5&dG=XS9Cy<b3|>AzzRVFk+H
z=I8KgDfukr&-GRCn`IthtFe7t9<&EJzrh@|mT3<w4`Spzx>zr6@Go#~2@{L{`D?4n
z?PG)CA8%u(k7EM^@sBl#?N1DizrGFnIP?v+#{z%%><Leb@)*v{5`V{@ZEFq0Uwc>!
zUjRpo2gBd~jy;9k+E<>t^w;;o)~7Z|dsTgdZ4}$d&eszE{ut;7?|O@YzpFm>4Sp@`
z@z~lH|F|#3S&-T<@;~tJuR+CMuiz!AuRmuH{B6f9MvIF7EZTwnLkWNFk^NiPvAV9U
zFY%vP0soocKLgD>a=;gQ7T<$<zPrvkssqYd{fb}5z5d%%`0|Rs_vPUnwDu&vVk^Mk
zvCv)RFS*`T#Q$=>mItvn_2>UqzTxfY6!FJjb^!jZK<Daz^56bZSm8>AxFU}&`R+m&
ze-j71cg@LFv@x7DBL1h8lBTO!jONt?!zJXf3H-wfR*EFP+H<Z*_@6fb|0fdu_Z0De
z-2nWb0RLArZj$4FQz`3o^)bqRW8p8b^1PXE`#T2UzoLl$e7LX_J`KeGY+8+h|5<!d
z`r~&u--tWG{~j!P*U>(FuwVIs|M&364*b8?@4fi{doTV!9f1EOnf%|t7?=FtgqL^U
za5TYxHWshBlz#(luD;<I<1UXD;r|fuf3WXsJfVgEXRNPqgb|egIRO61|J&sMKJx$7
zfc#fydH#P{IGPR2zh801TQzO`<=+nVv`2oQU&ZrM?06n=^LKfgQjU4*c$4Sd{~Wm(
zw-icwc;#0w&c=u@V5u~9q3``IJ&pU4p7fjIpE2^-@tuh{C8$bQIb=TR8~j#<9l`Hu
z{^jxu5#^dvyMY#<$lrJ#2ICkrEJ>b?>$9*jnX@o@AEP3^723!@@`)07k<xlD1+8!4
zd1zkd6GxOA-$%chk$(w7ak1_0mnNr@HZQG@5rn}p3Xkyq3%rcu_g4=`pBN*zR0@6H
zpbblFl)-d<)AH7ZPqli9m(MIO%E<fe(M~a~rHF&Eh0w2qn$%pq%UccRXzGxH($_B_
z8wj6q^`kV0*zv@C^E|cAiCdH!vg+8MWk|d5>NJI|2I&x-&Mkj_$;C@6mESt?(_$2q
z4qp4s&pA5~K1c9^%KF;M3vG+0(3j4f^kt2&Xm}2q!g%_?iCuV5$9QMh1D&NRw9z^g
zx+qsXVivTrBt@mPSoi<R@whhx^|by5ugxn)xx`q?x;mtGM(02ZyEYf0SMF@f2yb{`
z2S3eGyo@2O#Xyf@A&!wf@s;|~K9bsj!9e<jE)WOv35{SZG4${^WJPF<BgQ`SFJw(R
z<cCi~4@A6D?J<qH<>yivKKICf(`E5T$&dHSN#rIMghT%LE{`Ecd}1u08ZR)@)*NLA
zHr^|VAvtORQ$%gZp)uEx*1(qtsWi`}AU;Zwc_?{N17ln{mt4oawVrCbjIxwjgRS|n
zr-q&|x3ITbe}dZO`p>7q+2Cm8qjXfFpKVBcBl1MeqSQDZ>a}%Rs2y!}oIj{w3)@=g
z%GK8481s*QkMz|Zqa0fETZ+)Qw}hh-<`6s(3)j-NMh&I^Y~u~B|McIt4*M5lC$YD#
zdZJwaIiI$q|6KRl^;^TUzg+)~p+qS!mbo6vIU7{ub#JhC=K4>1SX0N5PJQ9p1-br<
z+A1AlhO(T}1K0WMq5oWkJLbGAE!JRZ=rczrjM>hetAaZhCC0TK36DNcCH`ue?yLXw
z-wyrfPQIc4Vvc~bh7EdDhyL?kcmto7qCLnN|9$me^rD1M-Q{cmaj>r=<;Er`xf~?K
zTIWrqoC5z`r(CL)^q*@!OaW`Xlc)059Yb72VH{7De0OK<;6C)<B%b?S)jQrd;p?D>
zhO5Sw^q;F_D^;!@;cn{H^<Q|bsJql4)`~d%jW4+p9W^raOz0kE+Yy%hutrDC4gKMB
zdFL~0TWEpETOAe}Jv3M@h2>-v4%0{7E$Kfwq-^@m+>D`A<zL_6yE*!WQ12+kj@j78
zuorB7*G3Wg#&3Ik{UWcZv+4!&s7$|n6v4h?N&kh;2p<={PGj{3*VT3{2FLny{bvmd
zSfr7o60stPGZoZ8e%IuO<p{5mXU!5K_r9=x=#NvWeoW<!`cE%-Ygy<&XIkhhAM3!V
z5!^RKzj$ZXXg$dFpOWRshn_!Ui8B!iwSL8{5cex~4-a8fUd=&jyR!I1B+?x^gjWg}
z;x}Cuf1Gom^yrnZcT2SYtfBQOt$M)mBekD1DW>zA>%Xa#6qtvNTl>D;6N|q3&v7rM
zEmpC}^`9%`D@UfT1m6t$=t|BE;tJ^;N}R{FYmm<e&zZpG7=vSK8P*0@L0LdqGl(1d
z&vj3oTcPE_oiwJ9)^Z({aBYHl{7p|5X1!J%6PlSM!u9lLCH|UwCHT~4uHs{RX&z--
z+uMn6DCxhI>0Zl=!TAMJ$z3r*|LKSBc-$(^1;!WV@Y_JX>P0EAz{kWc*MBqdi^}!i
z{PcdXpK<hqZR0J+B9ZIArOBgeA$Yp;cN1^$_b7B>6KTMDp}&rO{|!9J_1|1#nTz^Q
zE`<JDNUrmMZWcH%KuYG4!c|~g_j)OJjpQZ7tX^1=e$H`J!j)O;Vtf;w7Z>Y^t6S6^
z?kr^;)IUG;pDhb_=P{o8I&`3;Lyj<6TWvR4Q!-%ine#H;@xnQL=C8id6VB(x$)zw|
z7Jr;krM1+v7CFBO>Hy`ojT~%&xb74yn1ZW#<W@yz6FBOr)^Y6{rPz8L`p^2%N)CF>
z#h1((E3V9?Uy=3E@oIM+vPEqwL;R-8;?FEN=ek3={+kRRlo@x{D8L=l%;(y@V%()7
z^q;mjgEN4XcX!@sqh_f8=B7A~RjdE>mvj7V7Iz(#B+Lz|#<&KJRxs^#&gL=<gl|1{
ztDDrVNQ8Uf%;#<<QZ@(sR!RRY1<$3tb$t(EZKZ^nSb=6!SLOrZVxGD;_fjNI{ih$@
zD00a4-vUaRLTYnxR~C1anTQm+dQgE}oS$JB2;WZfT15PHq*ebdf%a;;MM(5kFe}%8
zn;5s9j@7OX`1K*&282rzjdT6Ck({jAbK$q`Kksb2^woc+&QgtBNG|HXxfS7?f&bMi
zaCOHWYo2>N%;Q=g`jY-zO)T}_8CbMJ|D8grt>m1MVg_D!rxK%^84K>$to~a|4(h+N
zc{Yy`#sxs4{yURrr$RaR>-n$hzthMo+5y${-`T`-JUZ8Z=W}1uf9GN?HMr7#p|BnJ
ztbrx{w*y!!1y?OO0h+yp(Yjp!9ZLG|AUU}2L=$foLx)QkVck*Gf0tt=-N2I!3#RSA
z%ZYUYw$@3M?J7U&zjLuKFK0Ae{ihG+`NZnN9;p61M*7R)Md-gH*rF@RpI>cfuZ8||
z-mKobZNN5-qYapytK_~k+LK-J$yyUT=_q4kQ#^fVqrDmWPY+b}pREP;pVs);pKAm$
z^`aO@x~V+(%M<MfDLAlxOeCH<!E-b6VT;1A(JT(v15?AO|C}$U{&P1cVYJpcudQ7F
z`2`j`F;M@xZ&JDb(^@~5^ub&8UpMcE)_*5c3*9}%b*LJt^|}6ANl6P5bn3sY<g^xk
zg#KHEl&k;rXIW2OI*B~$$wU3;{GIjOxeL@{?q)DzycJCQ>c7*$b1OCJOgOIo+f|Xj
z*AsIeR(|#0#ni{kfJFUwF*<2GbT|d5ckxdBcM7G+jeW$v6nRqrT|<iFfux-$Cn9m~
zZ*qE3|6PSlo(SJhN7kk@mU$jIoJa1iAaxCrdOi8=A;*iV=)W7uzoh@pgaYcnqge6}
zr@D3}dDruF6XVwEKli3_#ccK8O<2LzV7sC12wD)wxH<)jTnLxXO+KdTzbn9L1aI0o
z#;{JlyGp!_8g>J@2;bp~^m{4Tt)iB_H0i&~m|1ao(ti&!u6{ezm`N?Y9?#)Nf%if@
zTzB%c2kM6YyOw+(BkhT-xN<u4R6c<8J<Q0&rC_jw^C*0S_W;kyq`8Z6lWt;<BJP{0
z*|$UeTY=WE@vRl%v;FrPs8eeH-3FG{4p%F`fnVFsq5oXb#ZYShJ;0qSDuw?0VsW(L
zci{ct`tM1eKh6loEu3@x=W6r!azA*u8+v^j?EVK{yz0N(8JYPJw0kYS91k$V>>S?x
z68?w&dk(rhLH?H$C-mPplm2^wSfB2r|L#uu?=fZ^y#s8&N=~`{djxv^4f^i|c<}_Y
zR0_;t`+i0G`88dH+>C_c%i+#!AlR7npZf{4AxVuqDe1q>saCref}>MSNVa-%5^-%=
zxE9?~G+yYxSw;Of3ySOWvled7A!ZAD*}Y~qLwog~&qMRYZ#gC1wWS3rdDj2lJ%-eO
z)~h8@?OgKS4vgx*<AGfLcPg}VZMyA1um0PX+JEbyldGMn|JEk`cR|vBesfyMcLK1D
zp(NWbXF`+Ef1Ajug;bT`I~iFG{r6f*T0xDN%Gb!&!a<~D9@n}4yQ`o6I}1FVA9)A*
z?@h?Y8}Mejlv;2ao*DJ{$6Sk__gd=6ZpI6jAjxNgqwT)~=ot0i8>v<ADs%zgO+)Cv
zzaZYX@HtZdeIx0=2cY?*N&kH)>A#mzPt<=8G5bq7zANd!Z$j&LAPp}tkLnrbeTDw}
z4l^XxfA_=VQLIp<{!>F-PAOkt&8ky4W+qRmYgkX{FM9Rg!xicGZKS=9b&$SHop_8f
z(NB@;2k4RK_!z4HzF&AZv++XzeLd;FujBReC473y_1}Aev#<X9YkahRg8sV?eN$ky
zqJ6;p0(ifGKbJGJ)PG-vsw27n#Sr>$es(&$0;vCfgnWel`wrYag*gDrvdPS48<XYw
zZxnL_{t53I_20iDQGW{$)qnG|e`fC3f1v*^#J~THG_tuCm}X?pGGi>uUdhT%E5P>E
zP`9N2mazu<t<Ym={r7U}@3q7`0WEwz8u$w6vJoks$s7dh?*XLi=2U+#L%LiC^cp1d
z7)R9KBk1paNYpk)RJ*})6yKAvz`qk2+>gxJe%X(1xBlLYY|a4-=geM@EWQG%vi{yY
zMEyNBNd3KsG|wP2Zy^7V!J(+Xug9D29q6vtr}}$2^ETfNzptZ4ZG%ta@w&SM2p>)L
z_pQKnCEinQ;Qn4}iF=RT2>lKt%db!M_jNq8{o?p{3#lsC-{sjZByJpBYGf7uQvDst
z42&-o{sE|>{c;yN{AuFV7rss%crP{ktA)<&yQ%&z&)&y6Ue_`M)cV`a-6GbNpPEJe
zU7AJx{Y0w2^+?0%X!E7nPYc_!F5qhef=clHYcGHQKJoXjp!T!y_g#JX`!?$D58>~t
z6Muh#6#fL?!e^2fzz-6CKb!db&xybHQmeiQZGVIZ*JSGakHGRX)banB`1_yCIr(+r
z?}7E-;7v9DuFg&)ep{w~{@0>@-VHK0WL>NbH<1}N_feBwhwju&{%*}q#rq7~Mwaup
zJKKgQ-T1<J*&U4gAI!c7UC)KC^7l{R?-fvSMfQ)0ze}=@lFvUB#$~5uM=7_PHRt5-
z!K@PfAa5}^5)>`$xXPaoeXdJs;@9-~c-hdYN^eaWsls+Vf;;UZFDBT^30uEcwFT{w
zF(RiGRr|4HK|!tBa&RnLc(r$r;Cf`bt}U&tsDL^je+qlH_L^FQ7{{2dR=b#i6I87=
zhdf^R0SHg+^wWMHBVLY)nL~`?<#|>+YqxV0RxUUS9`vsrf75Cy(>4|JY^8vfv)Y1V
z*ILmX<%<z^`8U*fb^m<jprZuN98d<#N4r98!TF|+ZEJVe<`;0(j=vIb8&12poDdVo
z6<<t{dyYH}hyRX4v{9y|%76RX?jl-ih|xIL=F#fus=BU1UpxL<3Y=X$n(v-|;EwnV
zhyShs<gSh7{2yw(u0LMdbsdS&1{wU<YSG{8v45)4{S4AM2gC6>Z7NzzW4>`I&QMp*
zwQ-({>nFR?y0#kaGA|~GhbvFH+IOwNxx$N}-gH_%j&-zh<vzo;hBn$++Q3K97s&bV
zXh^ML8GZaQv~Gg`^T}l@{g`>RCa0yUJ;)W`7eM#<a8sYy+UtLb|Fe_5DWi3{jDB9N
zVFrCL`M(G#w!H}cucI&5f~`mX+as0#J5&FzRtQS*>ggeN(MNH$>so`Bl|_sQO{dN0
zT0gDy9Jahj{;#1Ht)l*)G7SD-L91?i;{WN?|BGnhPo>Y>-)prpHY;gIO{HBN{J#wT
zYd5Q%|EFTz*bdG2P;Zvdl62R?Wwga=4VTdak^k4yr+9Jv?}7h!(c0cmi#7QF`u`ID
zAB6w3Nox$j|JT#%ehj<RJ!y9PTZYO1tLepC|8xF-a2WjmI(^;8;r}suO1IO;{yg0L
zG{3cmm9+8Y|NW`{Uq%maE3?RJ=l>Ur{Qnv~Df$1gVe<cng&!CB|9!akPHbN4f9-Cy
zg>{Ahv-xjJz0`Aw{!36Ue;P4-miKG&G@kpXC_T$#M~qS~DbX-~Olf<}{QS#%7xt7&
zrRCRV9I?F0{g8d)ovHI@zRz>ZQ^z@S^?mhVk0<YW38nW@f-Um!35;?gUSJZ}<<Li3
zdqAcRxB}Y9(;iYOZ)5*vLk_FBSdMMjcosf)G2Rro#kC$IdE6Wy`%*!T+M$bHqvctm
zrP+H5pQ3;us8Y%~_#0)1pJnjZ-h;i*cxE2nn_K)U0p=2PuMI*|3z@wd`>Fadd5#iu
z`N_{huQx-KD;2{d)3o+3g;`jHQZ5ILz1R29Kg;uZt-&6%9$5BaqbIAET8^hr?F-n)
zHeSRL+8mM`vq)j@)0okR_gAQWmX{Dda6YXqSgKgrzY=44V-GiA5`W7O3rjV&*c-=t
zy&O#!X(Fzv?co?ZYPh|($VG1@sWBW5*NTUb>x&!n!t^k*{OEuCCcNjRvCqU=Jj7cl
zy^?l%*(d|GhFIS~N{Dl433In>xn<AS>*zCU0k9<T*A^g^geG_xva5w8U=p_Ax4mBP
z#4YGfk{W}ay{2*;ObdVzS-O%RaL5s#3Y(D2qwoOM!_Z!DNU2`K!t1lh!=7lV{z^Y{
zsl9h=-EB^g=)Ep<LS}6cf~d9jdBbaQ46&txu;-dXifSDZx1hhUxmJoJfAK5yK6B2c
z*mzxQ5O*a-%SEhXrWdg5Z&{vPb*x?Pd#`>8OoUbby3Ve2)3Zl9kKl=rgnrSRN*emi
z7}^NTt#<hItCA{8k={;GNA)=nPd%qXw$)(5Bg9%%#7U3F_)>*MLGBvFRjaBVp@FMb
zhqwyQtJ>>_tLZy3W1jkQ+856CpAhR25W2>A`gaMJ914Fi^<UIXX%zZTJB0G79mrMX
z<cw6%TT2-<eyt(=k@Z3kiL-CqO0FS=;XUuFC3?8&>*>5w{oq3Xh3|TJYfE!&T+S)2
zOTXHyV$E4?K59{GzFuj+dHrXp%8!1edRyyP7Wz-WxUfFyuPvU=8+GqAJ?q>DQJvtG
zw42CTAH7<GzSYXOtKWtHtlrrAe(FUlP1_S3%AM2+{b&E9jdx1iM6OEuPx$f`>V(C8
z81>E-YF9pwJp-+CwFZ4A+eoYa(-P`_X0AmX`p>J-f9~j~wPOOY!oSx!w(1`7uqK!5
zKl2y`G~o;H9)+%X?YcZZt-XIWo*cxolagaEJZq);&pqWl^mA7l_1w{dB*op!FxpJ|
z{8(4U6T>tuKrk8mR%pIhIbQpvJB4@h>x=`hYYpl@cQgq7=U$n5FX?}k>%U3B5_2K6
z5w_yDqs>xp|5l(?HuSa*{U<No1I<03)R@{d8`Hh}JWb_K%(V5?8uUBN^`GnJx$BwM
zI_D90a<6Z<o`w2jhyHViHuayYU#N@JI+LJCtjexOYUsadaKWAa^dl8s=^rybl-*i`
zYxU2hEG?g|I_-F>e&Uwj$-Vo)ssHq+4*e&8%k`gg)vcN3`p+5AonRT%%Jtt&N-$;z
zxz!pPu<OhMiqL=V!!?5^U2wvkElc{ZgIHsEG8;^0_R)XB(Vo)e`cG=lh7;<)Hr_U3
zeNz9m1D`(Pt{(ZD4z9eZC!ij#)4*m9<!ZTC*SWr<b6e&D#XO)1{pZe?vxwaYJnFys
ziFWFo$%!YmLAVGU#dRS$=*{h(rS1r+{&UrQ_my-fg~?D&8IyKRq)>+R<~L;<spO&a
zT-=Yco}66aav|qj|4j!<{pHku^U0ysAVl4iun3vblh9Q%CqapJ%9#$VdYY^M^vZX&
zboZrf0m}K{rT&`(jTR82k(lZ~_W>Bqvt`Jmnr=CD!Wv~w(`R{EdRn{wTa1M|*MAFu
z&h|y<zlF$(M<+a+gFL#MTRr8qaToeeZ#_9((tmPc5;?}cmaaCh@8mMzo=h(4zd58B
zj{fT+#WKp(b4d=lR^<vTdE=nO9H5&=S*|+oKAtP7H=+OZ=j$S_`fnEg39kOtLj0xt
zE#Q6~@AN0l_1`+4wcrahm9iEA@o@B?^9q!RZY*=|Ua9`uoM7(cei0O#K<;for}Vpy
z>vGDP4exUOw-kKzgtngQS3QP!GvKKDZ#6t=#ooG%eAn~46#h7)pw_S&Zf+x&lKxvp
z*{gtgBJisJmXlTJKRwXgw`L(wFQ#l)(NIzsfS+qs_@t3**Wq17YW1I9>^@se%x%b@
zUeg<fF+Q;fYxpci6mtEy3(VDju64BK|6%Vv;H0RszwZjeOwRzr(Bx>5GYmOHlQRM$
z$v`6+5l28pMQO95BB*ObZ4+ihMMX?)T(cP0Ro88^Yh=~cHS+#`=T^<!<1ozleE#qA
zKA-oopr*q2o_lVpQ@8G|u7fh;d*ZpM@rHQArU(8;_K$vgt3fIkb;bA2_+3?o?TOMF
zh!l)QE@=PyA(fr*4i4Y4Gxl#ZH2lxozkWzX3(QT#@ecY(q-z4w+ZAO=TSt$Yk^P&5
z(&D@MxtN8Z{hN&A=15yj?3w=G0EF&a)#}BYL%mTZ-7zOY`^Pu58#xKowy}TwP8Z)f
z?TiwR>|Zyuw#hg{`!^1f9T0vvQjrVkT)Yu94sC<>uRr2!kN1uS<6j??;&{CEV(i~E
z<f^L6Sj5y0G0(xZFcC2oAjP8*(<qe6B&2mZ=2!AiYvXbD5agWpkDgFxKtJst-_M_g
z^5~29W$a%+Z0TEZ5JHT=h<F0|i|pTcydlQ3gQ}W5w2g(Rv(ZRNF5bi{K-n1kHxQ}m
zE$bxA_RNH37>88mU^d6tzv0j`4O&Kl(SN`wgr<zKfBgDJFT_UsHw$SUi1siW`JI5!
zqwsfVmD4v1Hi7nUB(}Mjg`xdhg876osF8!j{^1QBloRdWQs^qPf3q<2L;E)yDI1E}
zn^A~iA^x?;J6$Uf&kV#c6}2-IfBCJFQ7GdBpo{j8Z+BL0X@)B-vVTWocB2|(jr~iY
z{TTZ<87VOKZywS-9lu4WiFzute@pSM80{Zxa}aVd7T5k9<c0R{NU?vbF@Ht-w+wU?
z!mOxT;t(pbe+Q%F8>0m_Kn@SX{8^d(I})K>l*XaZ)eTodUFhhDG*(Ah(f;u&Xp8fm
zQEv-T?u%gm4h-$zG^E7XzrztSvVUt(4pm)@{W}LOnD68tgnDj{Tn2atmG+PCT_1~b
zF!t|wCkfUR@5oKSd{jrYr`ceQ@Q(4xXu$zmDDB@YyoHv+TV)+^l}|<OEDY`6O0-V)
z|27~8|MT|mEZD!Jkb*eg_q-^ye<z_VXF=DMD49cGZP@?267^7wt7r!1vzEaAU4`Qn
zcmv$nzi9})9&h9RG5dEsO5k?Hkiz`d3Zx=|_am30{!T)AO3<?T9;2~;d|&=dT$%JR
zx?Jqv*(j$=krvv&%~%h>`-aB;Z9<&w@z&#D_%+yoYvo$J&3!V`w-nd?AF+SOi2d6s
z_U}s6-@Ri0Zb0mj{acLLL2du;K>1vT_87z4xp(3V-<ROuX=sz||6Ll|zs(3??B7i&
z@3pwn<M^7-!>~)&{bBpJ6**f0AH%eNN1=VMKpan^uDITV+0I8`|M(X2a=gR57Ix%#
zXu3vxdE5?mBmUivkd)!OuHDhX&P7ZsOYPrv$j76I>28F+9e;1E>g9oV5ii6Q%Qviz
z{bR1*ENB1Li2dW6i$!QZb<yJcpyj<L_U{?IeR>D%-#wxIyHxDoW|Z)GxIWH6+k6!H
zEwg`@|3Uk=4JFbRZLb~j{#9uI?nat-z)IYOtMo=(hrLlAH>1@4j@jVpc#qZCzl|tq
z5AE^2Qv3Heyg&OM?BA96PJ3kkPC=e%|IR}$X#XBUn2)Pmes`novj4~5CzRR0Z_t`9
zL`yjr*TdI{>twu3PWyKUX1I<0`yB7_(*9jvYXA7<t&d>;K1QlvhyA-BZSfW4IEEZ-
z!7m<Y|1OvQ-=Fr+^#A^}e-7I6|JnAB^9a#D_5;j6US6(TWBhCO>@7o8ZQ&dWN7@*k
zTP{3f_RTih7bsz)bQn3tQPIK~jp!faiDq88Pbtoe8{M3Tpl%+U89?qwD|V~6nA9^i
z&S7w2DmlABon`aKCIw6z=M*Yh%v>*HV7RjK;pnQF<2JLuoXs=&q>ktx_o<(`*!#k9
zFLKUTnYlHloby+VgJ(>-89UE1SDb}2rDo<V8AC-&RQB9*W{@N5jGG!c$H|!-&eoXu
zhp7C`Ob@k~@~^mjIAg^4I4f#qJy;&BKT4A_X3n|rD>qS2nQrcLtc_#Ye`H3Gp*e5B
z87-!Z`C(4X=q=|DSe7P79Jylux8n4hGNpc|hdD4lqfM(|OzcaU_p(h|IlIX5cFv!$
z+|4{KcJ{jDpf?oFYBPmgSQh*u7f0r~<;rIXrk%5+oSEawSq)QC75C>@@_ajiu`;d9
z59@-X?`%<QFZ4`p%8H}J96RQG8|#DZf%&2Q-WSt8Ig4r9r+HVKGgO>Wi`pl>H<~z2
z?ELBi%Z4*5jG^N6vmVWS8B@+DXwI&f`2;hY&Gya^oY6D07G_qIqbD4R=Xhhq*B8hB
zm|uRGf?udG?`d<^(|nhRqw7qqY5&X}Ym{Zj-)@^@)<#7O+Y348EjTmC-~X8JRd6oL
z%$>1rP5Wo*m@j2;wv@RwZK~?;i*rPiV^Qo)^P3l(kKjxi+ds!tIP1w)Ro4DFgU5H;
z_rCDU{cQDS&Y9n{W&5XBE6#y%Hj-bI<y;&~gmWcqFZ6D~nIg_PP-Df{Z`A(lAf1JX
zi?he{V9YPX<fH#>zO2LV*>En!lv&jN=?kL>gkQ+2XyJ^P`R*2H>^KJ)wSVfMJjZkS
zb)MRYg6*HPUp}5nP5b9;N@eYzsp2>p=PmhlodS7I<u{CZhHv}x8&z!o{2eTPdGQ+`
zY+04Je|{sNDPpRRxHvXKzshX?O>m|G{?W4$-!bPnKYdzo4x6osvyp87^+h-Hw)e%f
zf6j~2#}(&V__jRTKRu2$MSOf?oxcz_^UrbYvtH^!TXV$CW6s!Bv@}9`_<fyLh_ePp
z`b_(8j#@Bv$#0)<9)l&sFY(YHSb#L}x2l|RWc%l@imSeu_8%Z+?GOt`yQ-sa&u@a%
z#?wMG#Lf247TXx5$l23<w|{==fWA9gLZUUEs9A%Zr2X@&AZ_vdT^&zJ{B42V{y9_H
z4l<k@s|opv7UnWQY0!HW+doGcVt8)hcbfQZm=4fKAHL0z4}Mw2*#DNuPXW%F_TL5)
z6)nw0Du86v{+Z5Z(8zC8bV2Rb#`7+}$kGW>@S8@Q{b+_Kt{8N(oLW`d{ySl;r!~@2
zjQsY16n!nb(8%%QT;zrAzYnx=RJJXiB~AP9B<-RDbneUk^E)O35OaOR%=X^~M{S^|
zKc3GUATGB5V#HL8v7?3<cVYYQ0DZlXgLbGFYHSRR6)jQw?}>UCf_$_6_eYvd`{#El
z=%1JEzb)!KhExQo1AZl%Ux;pxV|squSNrEL+;i~U$!}hdMtsJfF#WUgyEsh|58Hod
zXdi&1VORsyK|?2j9I^d#Jb83Q$=}QQsQnMXh@5HvJuz;`_TN8j|2?htKUCU(#lOcW
zLMfZ}KN<De8c+XykgAzD$2kkOe|}+Q1~i%WKLjOH4QXfHw8O{&$Ba4CQqjU+@iV`5
z5a$q#2buPNFeK_@bc5}G07ePxBc`bR_eI@K!#V)^M?h09Qo!Hq?|qpTw*P~$?T>M#
z(MTu10>lyB{V=M+xsHVxXKRJA+g`|<Y5!BD{ZB(q#)9y>S`{rGQaxYVKY!gZ2O}I&
z`=49d{>P#gSA^~VP>j@!!zf)pNU>eallGseD0;L3)BdNSrA?Ife+*<eOHd+ZJY3rU
zEa>irx}i@Ler04NXisS9h>|)CwNr8XpMct{j`Xa8<Vh%(F{rWr7@soje=XW;iM0P|
zVf$Yx?f+Pe74<_ZmSBu5fpMYf6{es5rkf(==Ocw{FqSiOukC*!Mu>*syWMR63lM8}
zj1;r|&y)6lI`UNYWgc>yhg7eZ_P+r2*ApY7IT+LHj}f9HaDDegi;3+2`O^N+s4)5^
zkU0qDQXMVu3~B!x(EjhhxlI`RW&6J!<-Aq3fBxd80mi%5VO;43j4Ez|d_{}h{;xuN
zUW1XXC78)M5#tVbB9^l;CUrmB|5j=LXNv9Vg>kuFIKKsPSJwV_BBpkzvxBhhkI^vQ
z{-42^aBch!`p(k!Pfxx*aOKhd??h>B1G#3O?SE^z_J1+T{wQ2eS0OL7|2w4ppO2b9
z17Cyq2l8Xu|GB7j)Bd+rR6H1cY>V6$qaELZ@!bn>rG14_$TyIePf<FzV_t*5*WZQT
zxZH?u(%*sKr9TV}BSCxOSL)Z|xAt%Cv;99;+Wwz|??$%&7m&U$(Ec}}wXQ|G-7W3^
zmD2W~MjiYh?f+e9`R32||9^D*=ja3fndi;2E%&OjFq|1NVhsEjjq-4>@`X>9Mt?Lu
z#8E7st%`IMzZoYo@9>*E@Tr$ERkko(S^7C<6s4cfp_MNjAK;sg=1Ja+z;XP>Jlj_;
z&k+{p-=u@1VtjguMuIArH}7SeCouNE_{7bpNj{xby#%S>yz|Sk7RF}Y`Kw&N87HJh
z>f@WPOcBT0Dt@N5W929gQ_bfXrh<CS*cYFCD__j$7e{FLKDsG?^Sy1pQ(XDNaSe_)
z@cl_Me#NIkJ|pr><qKOmdkECVx?@ac%kiDc7mgfoEWp%1-zVq$k*t5dKV11@>Ywj+
zGu`ala#Vz)9DI(e>cX_L{^<pp_0RDT^Xyt#3>;Z9?-Lu(Kz!em_0M;DtD@i3KmC1j
z<bm(BM)l90b>)kx{{~_G^X*xVQSiIURjYrN7ropx5lN2R7*C*lU$$!X&o6JA`llyR
zz9Y+Li6%H(mHNv=NK^lOf0p&nU-7g4oA2YPsjOUB|NPZGze2!w==feH-)`ft=_~G4
zmC2huQ~!KkZi*6M{d0Vw?eBx_<+zp9Kc8Ir7GVM8YM}&K|LhZ1z7*goo^SGXMqixo
zUl-xXT>tISzpZ=;P*Qp5leI*7w?-W8knTTP|J@+lSL%O1#MD!savI^us_OOML0VgP
z^g2!bbK4JTs(fiD_1{6p2k6T?s{eMV|6Y}gqtD3qE=Qu&hlce(4E?dz=%<aqvqDvu
zo+$q=c*3ZIm<G$JM*@43t02BVYN;5{H^Z&^AAxgxhOEk49;|=9^>i?v4Nd(|K^^do
zm|0b>|AA8flaXtFeX^;OK>Hhl(%`q{DqF^(l`anJe*mtTrFaWt1zP@8^t?w^CJgSv
z(#}9z8H*BN{m(?Yb7Wh!`seqs_#W;8l>Kn4{uiVES64wl-}ah^dH$K0rRSSht?)#|
z@4AgazrX7Be=2(NUC^JOk9T{{!(I|)c+nrK|I6|GWUl|kc#q_d)c?t0{qMxvPz!MV
zv;G&M{&(QnqVnY|T>aOT*8fwGIStP`hgZ4&@5fix7UOx0*FV1-uoO>4@8YeXN8!8i
zp32oD&1Z-8zY}kO+$QzE7TcF_{qx&sl`Ws3v`$9-e~9-r9z)5Wi!YDS{x8PU;h*(i
zS?NX39A)8L?3(9^=$tv?dGn;AIcfBy!v1o3dCKul9<A(Sn%GF9*w}w#{CsBMJvmx<
zhX2?v<~%NAF*-~LYB!YqXY<U#nY?IWPnt8Z?AM#Vee}E(h2WO4^1X4c><O32vrlfG
zr_Aqe&5T+ZXRn+0TlT}4KK>%nPCw%`eJsv_MrBnd&)yb)gTx*zzu;u%<jPXO**f-c
zIfuw`Y|ewSe;UQWIGKOOVtzr!`NW7a<;*`v;W^^QXPdp{pYwB^8{2#SIdjRm1NKTd
zKWE2p^3VAr{^q9;eHZ?As7ycK_oW|terJkl<r`hLJb!K27$GP}FDt*#e<Mgl`Dfp<
z0rJCN4@DX{uSU(xKj(?~%PKp59}<nxlc){WD$IYKQfWjay+k|z{54DzJAE|pS*CTE
ze||f?0P&P@enFldMC|-WU%O}Q^lohO-wpY10(t(*rA)pEXZlF~`L+562;WMzK$Cyt
zaiShZmH7)1_G_XTnE&1wQLBMIKx2@>u>5xXQT{m|-3s?*e#5<QsWekq7i-1&ABp_-
z#XZH;|1?Rho&U*U{zs!0h9lG%l*L3Vev|)!xW9Kp+V)33MdyDkVq6jCe-!v!j3nAu
zU?aTwSsnM4F=%~J{!3K;r(&#ZC3HslFTn_NR61<`b5SnKP(}wM|0^&KeI&+B%ecw^
zp@?xlR<{4;R_qQ&b`Qfn@h0T#aKy#@Z@?X|Onxi!KM(r1AQk*#^cd{lX7Tee>RktS
z*lo!F4bFWSV?0gO&se;#x&m(`^S$eP@b>5L^S=rCKUL-b3XDD5^>6b3e3<`-FrN5=
zrT_oy{6{6lt=W&x;6#;{NRp#WCJtjos}_&Bt8h%pj7vp-d9SI;V#a3}(r7p1YTW<*
zeQfWs@#)^AnpT>7w7<MhnLFOzrOM8laShImGY94^EK2i;DTqq7OhWJRUcvhk$E3_#
z8Pv{^9dj?$q01jJy&P3C>1As8euKFeS7nTfcV2T>X6|_h<Cdx7ovHE>Ccb53#yEKQ
zV0d$XHSelbE^o@8`gk9tW{wT;ohRm{a(TWR#qkBEmiH!(5t>rqy_$8q?}hj6vUhv<
zWX&%x@ckt-T2^`e@wfi0e~z-T#5mr^ZxC>#hReRM1M`Lt@7a9&h^5ajWHR6EGgQ7X
zG<zl-O^Z^_H>UU{1bWn}Y~dR_{PKahepvt1%K1XZQF;0E_v7_&kK)@ed{*Qy$vHyC
zkvjgZY+;|p{9c+p08{@QXW}p7eWb0jh5a4=`j27xl}g@)_`L$wN<+j^*}}JR_zn@<
z4O3$3pYJaeNnDlHAHB`-H)^c^CddKnzX3{v_0N*1Oy1OgW5mL@Z&?5QEf{-He5<GO
zh2IL`Z+!#&<+n1~a_I+yKAoyo|82wir_RRzi}l|TIqnF}?WF$O$X?azpFOVDxPP+E
zbw)|<hf?f>ymUbBeZ*PWLf<=0(5GVk_dxwO!+qS;f2%6hKi@{_EcM?STT}l5dVG8%
zV?WeuW%XAd?=SShn3|8?OB1Ake$h?+cS1@kum5%^anA4$M(qtoS+FPE6fyGsrK<c2
zkZ-^67b~p);idK89b-HFq&zAszy8qPS<=b+A0F0!f9&^0zp`s(;z(_8jKlEz?=z&<
z`{E4i{{U>eV6AL1^}j!IQ5!wLu~PpBAuqF~{^wLCj#4VC|3#?(spuz~`k#qDXT|S@
zL=pGK+ZeyE|5@nqRlWX?mHHowo?#QnC8hrN$Mw(pp8z%cw*OK6pNRTD5i|dXAqTAg
zByzSkO5{Gab@0Z(p%|rE64w88<mWK7hfz)n^}qi<Bn>(n_0P9F9E?dhm|vfTYrw(m
z`X8(Rt*HO4$mu$?8P@-7_+_b$ak{05XWvT`d=s-Z=Ix8|#(=5+6X5yb7|g-*`ro;4
zVNhNFM?&tou>K#x?~Kxw%J+r@e>b-Zso0E?ScUazssGJri>E_=-}ScvzdzcF+}>AO
z|5xMs|Etvhja8`s8*#;L!S(+u#=}_u?_*qUGwMH!oc)42tZezervC4Coz$6OT|AFc
ziJAr+5T%aTM=4zexf`&)4%xq9dn>kABYZ1tZ-VR&>~nh^w!B<-WB(wmOG8~aReo^+
z<w>DIi`H#Bl;_r&rxElD=-rI%bJ#wQ^=j<Di1ixmzl8N#?7xildhEY~?Q2+X#Qsg#
z-h%C$SZ88A2I<0}Yl?>9KCB;N|B#SzdrElByf7aO-yCr;uRLa+8i(PhVv7M_iR(n{
zBOK#`GZPaQI#Tm-j&X9!mFG@2=S24j2>&k5g?ds4VxQ|Qvx;8CC$c9&4*D6Nlft&r
zGDf)nR~G4&qXM~QJ)*~rzj$u)anAGj@ap2o?0G&O56I$m>eX-9sBx2~&6@8Qv~1O;
zUHdR`k3je@$j{?gFUJ0p*gl2zGOW*Ft$}m3vA&6Hqs*O4ajqWL5s+tHjKVpTp_C`j
zPr%9n1lGfLtZ1v!HW}u4gk{@By|c|SOlllf%21Z|z<Q;gu$~dBii;}+gYrQB@hs0=
zvy6Ptcd_Qzs99L6s5ZOkYDwJ(UFSpRLs&D|e+=98Seb_luw~jV#Q8gsw!5$*zhrX0
zKlX=$p=_iKSWXv%v5m9bSY~Um<@Npw)?=}cFsW(S|AULvHnPV2VL|4QJJ-*R73_N!
zH?<3Ccogd!5Pb;SURa;NiZ;$6snpF?+uwI`nHZ$T_j7WpAx&1`)OMu#L9AyZ-y5-_
zl}Z_+?4;aKHY_W3eykM%chRh|peeiM9tcw}fWMA79>Df-lNZU;ChRkBd)u<RZZDpf
zlarg9m*<y{-?<lQ+ljQYUeCjRROexxGTlxLYgEUp5$5PHJletD7GAHYLSHh*L6dzg
zFG26CSW$0ICd|*3d)Y?y$^4Rs$K|7ja?xH5OKz@Lng06`{#>lcqqKFjW4SiMW2-Hr
zhH%m4{7xgoKa6v1YfKkcw!vt>tS-D9FE=me_wu(x?^fvFhV7l$o{H@P$e)J&Gq8Us
z_J6{<3_A8;{T}<bVY?OEJFp#!Z35fj*s^TS!rBh9=V9A3l;^oF*e3^L{1KP?bOz@c
z|5G7nSgw$#K89f$s9(}U`3zQsFDHK_WDq{$rQwf4d@HdsEn$9`9?1`MF+CDL(>EGn
z&@~qQqp+PAt~giK1#OUa1QE-nD@FyEFm4+j29CI}b^7MN3`R2SUKZpr^;evK2HR(`
z@}ArY$GE>s-=rP3BXC@dbuw0V&9TZk9H)wK+z?x~1BO9(;fy2Vc6j!c7#?w^(7k2f
zDRmrH$g5+X3%SG>9Y^|@CdR)Pc{_bf5A!2B5MLBml%G<0D?Ln~q>=iePu7|^R}1UD
z7O4-^i-&)_mc-1nPH+#;@lhE$SiBrwxt=FiFRT{+`#JbuLBvNwe+k%1Y*%5s6l+K9
zvpp}zwjewnhkdR%R_Cg~_ZD7sgz=T`TgRp6D$r;1(*1p;uQbeF(o3dzE{?HEe$lE^
z;mUIrF1%jkCd7MOPPM$;YPqqz+*p2oUVcFV?!q;ySFc&KMvcP4nuSHRYSpS;yQnB$
zr*^zfUHo@k{6{VBZE1$<nYQB>q~lktEpW_!D%;MZI6nvLDD2Z-rm<hu1$m0sYtX1k
zi+u~EJ_Y|0amOL>Ew<m`m^QQt((wcKf5blf-~m?HH?fPb8PYdKe<al!EAN3D!P;U!
zANz$^X>ZZq<UWMHoE+0WAuo6p#=$Ec#-84VFwE~?v2MV*XRxIWS%>vm9KVDuuhBQK
z{vF3#u{{P`^e5TRax&P`-ad{kuW_u>=lmzO+p)ffbBGJC(mSd5vHjn+AkSRFP3bl|
z!}B?@>g<%(soOB@mbY#rGWMVIkZ#@wZpHQzY%jx>`DWfWV`aX!U`sp2@|}q-%2ezq
z_A$J|PuiLCJOx|Y0G>x3q!wda^(99-)(lTu6Q-Tl5bv>NgMCqkaSltW7TUyD*x8N!
ze`7^I-)Vqz4YBfGcMewEzocKx`*vM$rf)vZqu;=Lxb#<H!{pg)9vJMl^c~;Exp%O#
zJ=}>E{XmwJ^wloGmSsgb=9y)+2<!jU5@wTk#cH{*0X1sYZ@jm-Z^Fq7k%o(~y%;Oo
zFY+Ym9gF>&u}|BKyhrsX`3J*rqPfqrUQfn)8jerL_9SePFDWCoedH_E729I0|7(i}
zG2Cr(aN8-1Ak0_UiM{Q82Hl@y<?~K;)G7Pn4`JPj6?vCFINN6u`>$f%h5c8sWqDM-
zxVQ`Ma}k@d5kYQ1oY!F+m01GEup5|;H&gCBPdh{Va00gTu-)e(iYwL6F&AmS!?Ep-
z2zjm9TV5MrYT+FotDO4~e?P%m4P}>$^%U$=ra#s}Sf?UB-uDi|x(q9>S-E#VkL@OK
zv!L*?n7`&s__y>L!~H{^y_;a$8f$Z`Ef5FO3SIVA`fo?$+@WA*L27Z|i;nCq?K#R8
zLw+V61WGl<S`)|h%C@32I?gxYQ)Lk%dUS50G69a3)JNFk^A*eDG^{Kamd|~Ndk5BO
z*q@Fq>mF@D(t<j{2hU7j`~_^$4#d{sI^?2zvU@2s6U_X@eJYj4F3Sq}l5%T}{jl7m
z>=HP?6z5n!IG^G%%M@D~)8KJOtVyg`sGqAm(w3Ehfxr99zP{ugWrsmoDOX7c)6gF0
zSf)%@c+7H_@+a$pmFZx8P!G!;i_y&|Q1tk7qHz<$e*YKu*7>++&xCCn>P$c@#D_KU
zcPiGIXq%(3PQ|svk1Ebg9fTYYFW1^7N_K7K@d7{lLB5fQP*cxT_Y_~pZ{pM{-L^@|
zKRE}7Z#Y5-o<k41mb5IDOx~B!1z{6q=h%}TaTKB*q&S&hrGF`x|02<F%Xnc5WBKUh
z$sm&S=)90lNKM4ENPqkrn;MMTf|IsXA~g;r!7HOQo28L<fu(MeYKl5(fqxz4Z;Mo?
z)P7Q%2#<2IJM);FMcu*82A(2HSDup^WoX!JxpG|Ie_SYXb8E(Oa$^l@H!SEra7bbV
z(^26f0-~0ZII7|0dO3v!c{RMe+`@d{FUqS~ke5>@UbB8-^;$J*73Af|^J~WoYt?Ji
zuu;Q$wd==g)QLB$-?>Y-;vPMF_3qQRU;hDv1`i!JJk-bx;lJ+})^Po5eqQyWntAy}
zId$vSj>oFkt=^!1y*dT;>(y`7wq5%U9Xs(ZrWY0*%w-KXC#L|)DIbf~L;?!q^%^w`
zT9)fFp<UOgQB+i~Uj6zF*!#_O3kujbuU$JHuUoh2ez?!oDB@@+Eubv4#vHqVh2ygo
zpQ-ZlV|lTHeDv$9=U1;$19$hrnl)?HDl9B2s#O%PUAuOjI*6@aox1hv<9~yO_}{1z
zBa`G7c-3-qYSs)e%-W%w(NXbVkzmntBp3g9Yw!zl-JBRMlxlf3s^L#TH9lYD6;!WT
zEx%fgf|}Ly&=ji|#_Km?$FW7rwjDcl?$Wimdyk&K*CVkbdtS`Vb93{n<y9-l&5u>D
zUcE+M^}L#VVyT&rTr_CdxJhf83?>9+ke8R2k3coiJ1rL@%F0Lc!edX3>Ub59hFc0P
zFNUX~>L{x2Jsl*ZUw>!Z^5qK`&s!c$3)(CwF!6Nl+HLuQlKFENFI+Kq(bDA$S9LpV
z#gvst&Yv>B+lrMFM@|_rH#(j>d`$PbbJ{GJJFU&Cxx;46>d|#RzQs9W-ij4Rt`6p}
zTsUv_!oX>@bjAGTM=w|y3|h5%!O|70yDk}m_a{qFE<NH1oLsqdg`8&!jyZDaf}k=@
z?IF}}?&^+#Nz3q~7j-UoX4=A4or54cy?psfoCx$8<_oexhv0+)XWn5)u3Wuz#p2Gv
z((<L^I6)B1oqI%&-hGw^#~pD*acBPRE`JfPImAx)fk9vj65(ZmQ1>4FmUawE!h(as
zfd~`gC{o1{5rfELg^S`rUc!_Q+-p2#9LcRfmnjdzZruXLws6&|VDZW$k1h$0UAlTn
z&^;J2c@@(@{Z`T?IfH}tQMNh+ZA<Hb?4ULa4neBQ$+7SQBgZoAXv>lPPOdBqj8yAW
ztU@_x`JKK><RpdE7U_%9X^P4aozC!Fu;|E@0h?s7bZ~L!WrK?cE*;cn!N8@RI(1&w
zX>bo|T}~8MwpM{c?LkWqK~hWRmL(9Xak8`=BUv^)gq(W>+u_{#$E;phvb5h^{OR7O
zy%l9}(6U21h;UdBmVEb$<;&FXLmtVsk}z+<f>ojZvWvo~j&yQc^>laY9;Mup=ap8q
zWS5CMmOS+%-Buj`OX)6|H~(-ew=9Y1`tM#^+)8gpsZ#_jOMS`0l}8-CdSS0MeR{Fr
z`t)jV3a)s~$bO8(PPS<h5bx9p<iv_D)gIBMs_X?Ls$#k08VWiEVVkiNV9Kq+`YtVj
z;<D^JzmvBLy~6ey>JO~iGxj5ltCH$NGK?WcEkssR$(wROWEEaIdujUR@=;ZJWFv?g
zarx_yi7iWqZijY8Dyr<BQDsNztBUPm!-&F{tJ4arMVXP`$y<5Ym%LS_mVT>2RVb|5
z<UZ41t_;mp8MR4EZ&eaqt}R;fRjoT|gqB<}_y0)S`(1v!S6SX_dzSvHrdxU(mYh{j
zmD#?%cOrU4jkT=({jqC#@6q-Squo30vrpQ0pS0gTY5$P2dMfHR6-QzAp1AI+UuBgw
z>c}eY3NMSYYci7Mwp^j^OWwLB_mPj%n@R=wD78Zs@Y1TUfJb#$Q8`AnSP_rvu_7MT
zWJSERF87|k9+lK%kJ5UqK)#al8`L8zzzXCmDZd_-lwXfZ%CAQy<=3N<^6ODa`SmO<
zKevfL5W{~mv^8bjPkYjAbg7^AaCrPnY@f!q-910;`4roE|N3bUhZ5f%@bjMb*j_y7
z=RISw4L1C|X9>0&vBhf!veY#j$31?U<E|-ko7BjQZFKXBc%H*;XF*rTFbp?)4{wHA
z8UCh|e%iB*0Sk*p7d9MUtNO9AlryyPz>Ymzx8!Mt8Hu$S(mbFSc7_!eo#BnBnd|rN
z1=YeA;B?>Z74y@;r+)g=o)f3q@@u9>^4H_^*8V^5*}*)P#(%dP@h5P4^uV9@DnAnJ
zL#*4*{dvzqY@OkSMdy2?3L9?lM->L=<%}w9e{Qw0g~ey&jxFqWYTl&6#PY&^!wQRs
z6}BH<7z{6Li15P;`DIkc=?wjEBA#dnjnVzN{8<8jmcXAS@Mj79UtR)v2`PYVuGvPV
z5#E-aXj>x$ORAZ0nD&z8wYtM(D}(XaE7~A;D@-MsB^GX@x%!47=lz#U#Q*c#9?l#)
zmwE|q@as6UWc-Be<c7yPJaa4$H#ir)Qc*qR4Z|&`@9YILU}o89(ihzecZa8={zP7Q
z+#uYp$w|mwbUqm#N9m6Ag;Ra<DjEfT+hg*R2*d9QkE8P39Uiw2xhVPH@TYxP{=ZkX
zC9Kzb!|hYy_Kk4+ak%|H+~$VurGB_=8*ckp?P$!15d(tuV<sQiA?Ve$U)SD2kK*pV
zi~FFj+<w}^1;N;PtIhc?J^OdSkE$?1E2%O?+a+w6(mDHmYH@7BH(MMvp~V9e5^CS!
z2fP@Czvf62UOI0gssEVxXZGgLqq#JHG$C8*%*meqW5Rdq6NP`{v4jMuDE>xBd5(mL
zx&OeVmFuC&4>}N&$a~4S_ZM6*Uh94c@4LC}(O7-2TEFRtA*UJ!svSR8tqvyPy^9#E
zc&-GCwM8)RBIxkCAH_3XUI7y6ebx(qdY;NNIeD3p*u?T4;Kt4E#)xCp3K13N=I*8Z
zF^JKBZ9PNBaxTJ)0N#U0XU@5kaK@{P>BF4!xQjS8bi!2|%Z+WqVQ%aL{LSO8Hy$(M
z)r!BxZfrDm-^~4fHR?J4XCy55htW9g<d4B7_m{shNdBeBWbUurFUqfva>@OT`wjEI
z>yG_B+z$$d!`k3OB|K<fumGkg*Oi0fg5`a2;K@P1f&+?i;LAaxU^b>7bF0b0*n-DK
z;UHHIrWEi8Ik|aqFsoqV5FF&Yw;_qif>+`=sP5i{gCzxgDKEFC%M_Os^g<Ek)|P|S
z1rLwKK^=Do$eMzWP?Wh1T$XsMpbP3Vx1q~=JEfp8Y*20^cL!oSwV*{F4w|`7<KV1<
z#~49d_i+T<Sa9%Q9CUME$HAoqM+G=2mV<P`e3I^Ra8toD9`uldZ3Rd1pr^Y9GCK;k
zv!r@U+A;<2;Z$y4_eJP=!l`~Msx<eC*d3U*Y?yluGnxNe3!J)^yH5Va?XiCyvm47l
zkOgrgbBmul$4<bx+!!md1}l}xu8B(tOKyzSDQDk}&f?QDvAla(5V6m3E^m#5`<}bg
zWf!kLIeCk)TR0wt@8<u$&AXfbiV(Ht05O!m>7A2m;khuM$?-S6c~a5+y&+bef&5MB
zbwvlDF}d--$zk@S+KU$84bV?;<ZT*TbOS2hZL%B6y-iDshN0%&rXR^svgj2aHTzkP
zX4S@bMtU=;-lmbY4|m*tW`BB7Q<Sbdz#JutzU_e{c?R}29pKdX2Lz~CiUYsFXYo+A
z9OKJvu}^WL28Dl(&f=Hjr=w-%EsG=B`F^6_Fi;$Si2xF^9nOn9zC3s}LoOdAAxol=
z4RBb4ML9JJi8#AVM97jw67sAl<S-l-jl|1Bc`H*wHYxHpu9v*kmkYUEk<Lg|-Z9&S
zTxS!}`wY%Y3gM&tJ>1*#j(b-^Zi_<RkHey-Fdlg){8z{>MXqlJa$+2&B;Vg{6N$YY
z&PVzGj`=@%kc2F#AC^=D92Q+a1LV{hLW&eQisbYXA@vpEFM9IMTrZ@lO+@e2I4^o@
zIz>a#!t&N{myj)^kmuvDs3ys|FA6DE<WZ6hp9&db6N&v-oR`?~O`~nK5b~mUF7rPn
z3i%~t|ELJ$;?6=!6uGEA$fcu&Y*b`>TaYW0LbfS#DaqBx3)!VeGhFL=*IXoIw@su4
z-i-56S|4UzZFyKi1`Wa*xD1C9^3^D0o>MfY4MN`Zsf0{NAs>%I{u+hMaf*7wH0RwC
zhY`&8Gf~Jd8FCR?bvvAowD$`T^7cUzG8=_#fI|s6H3|vsehY-WW08am8iwf{7KJ<^
z3JL9p!|3GQxluwEM<EYqNM5HmL?P=tMaSTdmv_%j37LpO{v`_eQWP@ZDVoKQ_kAcK
z(^1Gra9HFgK<@ud$gYUU70kTWiG_KEwlwaKc@MV7nS6MZ33K4%Q1UuB3JGoN81mt1
z60$f7*(D0OI0^~-@%})B%&e7=BcqTr8L|tsZ;C?h=M?>WBtkyEMM5T{kSF7?XdO&w
z-jf+2DMjjy0{QD(Lee&o*uTbksmGyCQD54iXLHa`MvX@y|H;^o<rV&Xb0JRSFxNsJ
zq|A%`gd}Vt<#7PcOYENfMNDf7ap!8kM8c<{@Plz!G#BkH*5MQ(XDBiWeWF;$%|gyq
z<dUf%o$eKKfg<x@X=9yt3At2}?F~S>d?w^7MGoi((lrOqE&2ZSiX4m3v2M+U+@i>D
zsG?YLKOx%`!S@oJSodi{?p0)cLy#WJg*>Rpb12PN&ohKPrpV^@AidH;o>t@~=Ct=t
zAunn|J$+si@|q$i3<Bx<m5{d-d2cdEzgTsaK~|AB(Vk=dTMGGDk%v2g3>YNj3q_g@
z02w$#$Ty1k9YF?_2>Guf_n}u48@yh~Z;A{=Uo$r3dLcPY!d574XGb%Tp$`iwP-GUa
z=~&`TAw`N*8xJz<8zJ=-nKlJvc#Rq?gQkjHLNcPQkd}&co&hp4A*8(`yO7Y>s5wHq
zDsmJqt=Q<*LV78(3mxXzm<>V(DDpVY#m3$wB%w%*GUFZ-GFp+MIw0fU5i(Jc&KLuT
zP555OG)3m_2Qsk;apwE86bWFHVv{-wIaHDU`-4m#DP(~nE75(6?SH6{Ws119L8hz`
zQliL#O!d?YgdC&DQ!PQJ-6mwMBBvb)a==qUPEq6u+_+=YvqH{N<a_El@FyV~6j{yE
znNb%OE8o9Jk%8z2#%6XEa=9Y;y+CG-6_QqDeh-k@hY8uDNDW$~IctU7W)rcYm*Biu
zPhbAx-nap0Vu#!&;WJVAlW|ydG;QdiPYH3FhF6G?`JF-LW`!gaxt%sN`IC^8BF9by
znO7J6AlwfWd5$SQtg8^GnXP9TZRq^5LK2E>pbcGcn2?kr57SC4Tx;|wQlB<-(Zxnj
zb6d|fv~7#oM?>#ik@smsmpp6qC~`M#=+Y039z{N8PM7^=^z3Kr`IveRZ&)OH6uE#l
zba@XUDMfym406OoAsI!!rVU-ONQe{IdS0guJ(53*M1B<M#nLIc+~`rHF>UBk+l?MY
zUZf3O`J&O&!qzjb8_23pjUGi_q77Z`;d;#XQ;Hl(8+vq8AsI!Q(uN+>M~KtX*0Xd9
z$gxv|Box_7vSyjlqsR!_(Bn=sdK5X2<oK(Mo>sP=vuQ(5*kSZ2@+q$9*xFZ&9!1`Q
zy^Edrh0&wPev~;W7rh<y?poV=+R;j^3xp&T8A&UV8XzR4$g#AcCr=lWQ3Mx>6FX&v
z(bLA(Gj)HEQ_nJb6j@IjdfK%{k0K3`li2AG8a;|EXR6P5!{}*i>v@+p^vvBxk0P6C
zL(eLJB-()@?eOdrJG-@zj3R{?w1}-ABE)HD>p7RDbIvRw2}KT|4Lx_I(W6KU+R*dP
zHF^{|p$Eu@Ek;j!TTg3Rr1LXIk4?mezK!$7ddgpXAMSeCyVwQ0C44Fh|0E8J&M5}D
zumCy2mDnNFA>=sP(2H6NaXQ-M@u?tx86qU3$a%CZ7ta!s>SW8j&lF#>(&*u%JeEAs
zb24q{rRN$wU2Jj#ZRllNj2=arcLljTWAt>jWjY@Ka>ZLlPdA(Fpl#dyozYWllOJhA
zuPm&`GRP?MEN$pj?S-Ve+cLj0r&kXblIWob^`s9L;`Fr1&9tG{9Aoq-Qj^!gwHu9|
zUbajw?csH|7(Kmh@&#?^^-mZ*eQYv;GB><y^eEDuHgwB>jh?=?%ty4LH^%ErJLqSV
zrL>_pbr$0Ex5>w}p*N2fl2POg+R$5)LQ(^4nVz(vw;pfw475p#mhv`^DZm;HvdNPq
zw{JCi6qz#vWb4yHQiE-oPjC>s<9#8CAvU>&HgwxBLY$#C!S@E8*q!y!Qqc|+`8RFo
zUByCD30tNQZRp+Og(QaAg!Un}eSr{XxJ?eGmAL05qeqeRX+!V5)aV&u%b*CH*nM{y
zJtJ+hlx=6n^G44on_Np9djH2pk0RY@Lw9m+2v%>jEpsYU{Xk<Oi7__$o;LKsUP7F)
zHrak4$U~EbWEA<1{m_S(7(L@`ndcjUJaUTBGu|fGvve|>jh+cMIh;21(R+;^Mf&#w
zd2E-_Gtrj0kT&%3&y1c)HW`F+i9L~nbfCRWwuso!{cv8aXEphY(VU%Z9e?d5;WJVA
zd>j^CLmT?^WFf)+VN62Krwx5(iI9{cf2R$7_7ovmMXsY|d2X|i#1uQWADQCk?-i0(
zqzT*S3%i6kQ*D_CX+vN9Oh{6Z*JveP%4saEU6J9mp}U$338vYxebNQw<$gj^iWKz)
zd1acAtRnBxhQ7L7Na6rHwz`u*UOPibS`(x<_Ig@~Gu@WS(1yOTQ%F*gR=f`W_L`84
zB3o#4-uy~PaG)LAv7JEv9z%=6b)d*$13=ztDI}}NSlZCH2MI~cuw(m$HuRktLeh$)
zXhZ)|BE*?#%lt|k`tEumNky)t4gDvt23R9S#xp<JhlK>Q?AU6z26^vIAt^=Pp$&ci
z8zEUmKI;eaL5-%=lbCJCmZ5e1u&t1^BKOmVev}a6%&}z}@+$dwj*z4x!!eo{`((9{
zj3Se0LqFXhBsj>9js4l!zitweQsnK?AfG)ZB&*1cw4tBBBP4OK9orJx&@a9hl2+to
zww*7FP#3TThuAVZX+yv2C?u)KXr}G!kwP+xTuvLh`%odlp>}MA7`cx9dySBkBG1!?
zesh74tRk~}gM53Nki=X&wqEGV#J+n<NLrBxQO~jeWQ90MTjo^S(C>c|l2l|WZRihm
zn@f9B<W}0y|8^A;%(G*gPK)&8SRpB!hz*^O^I|=7<u9J)cd>Q+vPQyZqwte(Sact4
z=&u(DNgNjH5OM=;=x?_PNh|U-ZRnn-ggEmpnfU#*p^p2Wprk@YxD~`)_ZLAKg>K-L
z;JFRZfb#udfgRziG^4)TLr_YgUR{B5+)0A63eBP+t>!Kflvrp-*pPR|T=!H#X@%O+
zl;*it333+MQmt8gG53B!NrgJmnC82$3Cd_hYg*ubEht!QNBFlvK-JxXfLTr{)Qq;V
zhTBF^R-uPzfNHu4L5U@HgqKjN&^<^{TA|};Qfs-#2y&L%Qgdlji`-3uk_y!s3RK&@
zO;ARmD~RImUj+rr><HP6V|Cp31*H_)PP<yy{Z&v_p?S<#J-1;CmPX=mJHk=4to7ZV
zg3=0oOVirGoh-;%ZcDlSff~9?1tk^w8;xrt_cTEng<ht0ZR}nxC^*87u$UK66L+Ve
zltM?*zBYAV7nD_~A1{<<?ruSe6?TOGq7`fIR!8S9-%l%4YYfnSZd*alk+#$$XiBlb
z9VRHLP|5*n;T|j~qtIovvMt?X1qCH`gs*r&t=tO)r4%}ZDQxZDE-0(eoiwy<+@}R4
zj<O?cOH13<{XkG!p$}<l+qu69a#q?>N72@{cN;-C-%lzuk;b-z+e=VJq1R|_JG%P|
z3Rc+>Uf~0Ea+e88DYTUKwzGS>psYfV)8KY-(}EJK?Fg6C;&yc(5R|r&nA|sT-gH>y
zFC52w%ofw#{Xztsqr<o|IE=qQo7=<9L(_)6Q|JL2-JWhsK?#MbO#|xX4i=PD=$s)y
zz1>-YQVO-B+3n-55|mcxL7LsZ?gl{_g*a~&>*wAqD67zTn%(~H6M~#$?0l`D*&X2i
zQ&6B#!{I;!-Jb*{6dFRaJIJlqM(SRn|FR1^*ew>6QfN5M?hto^ptM3kAE2S`B0(92
zzM|PpxF-wBD%6t(beOwYkaMh^uh(dvhP(F(3KZH(sS)lgf)WaCq}d(mekmxa&@nW-
zquf|qW;vx$N7~lWZYx1)g)U)dc8ohjP)4CnG`nNn*@ChPJx8-U&Rs3YS!3sG4f8eL
zJzr3u(7~vv*aY_$K?#KlXw)XUPYOyZ)R1O(lA9HjQs^t1-O29Hg3=28i)MF!w|+a8
zMn)mdaKxs#-34V8I%_1*RCl5v=QulGE7`A|<}MZ#D1?t=W9r5|MNmSaF=K$HyH^TI
zD)cv+-2>enf>H`yO0zq|eN|9ep*v}IXS!br$|&@i2Q<sgNBhPEs6wl0c4xc%CItG#
z$J_aOnr3&7J5*4h&=A;_*g@_bK?#L^q1ipyJz7vwp|fdr4{<jNN-4B}X7^C{RzYcn
zzM$Ei>pmqYqtM+xP}1e2C-SAx$uzt3++PGaC)oLVn`ZYgw?PL=1qz);vpe7IAt+%Z
zF}ss+UJPz5GP}R9#Vm5?i$F3G=!?Vn2Q<5j-ID~R6?&OwcZqwMpsYeoXm*#n+XV${
z!*ol8*U;=Pb6*maRA>mz?&0odMwddb((EpGtHB1Kj1+PUfR1njLBWZ(t|ZOw3U{EO
zq(Z0B>>laP5R_JEKFw~4dz7H8LI=|99_5~Ebe&}Ds)ba?R=PJDT?);n*<Iy6W^^eu
zg}vR??mvt!g{ln(I@<lO(Y4OjHI4@K7`F~K`F>KNAI1Y6>vk2CR_IAet#K)gGF0eB
zn%(2v1%iT<t?NAKj~(x>6O>eF7|rep?&X5g3T>s?UF+UsbSX5PX7@yQm(g{yt?T_f
zpp)FsjV^`GXTH|CxoC6f`YFWQbS&kz5R_G@1<mfs?jS+IDYmX|G`pv`GX*6Tsx}ko
zRClG(rI4Esbeemf(WOw57t!hNO-9$LwyvvbcF%AhH@Xx$n`ZY+_g$k)p$0U&XSqKb
zT?(xm19Y}qw+l-nIL+3@2dCJ2x0|4(LfdF|&vC~KN-OjX&F;DGLP1%D`1z~Yd2Y(+
zI^EWF4$bZc_X?v+p?}isp6}jkbSX50W_P3eveBhbUEc6ExnCGvXV|)~q1nB_&BG;)
zHm}fHn%xWCmV(j><zW0Ic9A<+P*$Pmn6JOMvjhca+PW^I*}d3ZWppX@PBoxQ+zm#T
zLYrxJFLiG=x@;t7_X(UAgPSjZVOu+lgTNK;TOv?&R+xgVIE*LR&NjRM5mc<uJGeSx
zSGq;G!tnN^LOW@8uW~yHDp9CAo5j`cXh9nlT1Oj{cIOG&rch_vpljT<f_5pCss(hd
z%l;K!LRBc<80b3pE<r_S+xgnU2(Ncv5LB#ChZxWe?x%vLD72WD@fO#|y(r%=QHT#q
zu^Zjyf;K92Q4OG*-2Q^LDYQQ?{+r$Df_5pCt_gIDd!(S<3jI_I=vH^VprZA5zFw!5
zyv@BqP_aTyssr8bW&}-9=r-PIwz_W%Dp9C)3!ppP?*(mCXow56&8^*?rLj$+bv=RZ
zbUO>$rO+5!le^q8f_5vkm=^hN_b@?4=h*p*O$XZUo+zkTp-WjB_qdk|nxatC2|)L{
zcMB>}s5Wc)KKDgI8x;xypdIeN1Z`93{joszyE#3W<y{JWoeQ+n-A~YNg`PxHiap>C
z5L9%oov$Bxr+LslP*AZ#$MGKjkXs^XibB_;R~mcRJx5T9LQm7SKH_c>v{9j-SsEGl
zQ9;`j`ka@;qwYI`b}7_@t@kna2SK|PTHGG!aW{_2&i9MXv-8!J4d4m4i=bkKt|$U}
z(j6;kib9|9M*fsLUr>ocb(#VF)jdhjMukpAMa7<WFB7y)q4yF%&$!zK?NX=_E!(s1
zOM-SQG?bO{oco!eq78Pwa#{jC?^c6h&i9KII=2JR3vM82ijBnV4#asexN-Rl&t><}
z?Cx?ogp3EtNT3Z4;|&XdUUruY3eFExAn03~-B;W*1!WX^c^c5G?zMuF8*QnvG`p|4
z4+(NM*=Re>?(6QGg3=0&WV3j~{Z>%o0$b`G-aP;27UFJ*PMkuUX?EXqI|xc$XiMd=
z)BSgMq@ds;8_nhg`Ib9ZP)4D3Q-R)gj~A5ui!DXF7<<S4iy-G>8~uv@O6(u*HbH5H
z*6<2{*L_Y<;u2eG2hHw3-H!!j6*`R#H|x3>p+J3IYD>*!rM%}h6%<@%qY2f4-go)p
zG#-!@`i^Gz19zIB<mI;1fh~YObdM0^Tw$XbF3?BrS%T6EU4j-H``EosP-3$!H8&3Q
ziTkjitU~9}?0)M0T~O*uTPm0i^e^{2LBUlvdWbgYGq)D36!N9eAR3y_-Hw8iSKCs<
zSj%6yqXao=8_i~=eCZ|yr4>4zSISrJ34#*W*itcGt6#ep3(6`qpO$O4d#9k(wYJn^
zw)ua%&kG8!v(arh7yHKjL{LVd*O}#ST@TNI`F`?xTk7xwfxdH_336_*QQe6^|8e^X
zN-NZpm&5liUn<Y{6I*Pl6PWlP+!cbd3hh9+*ni!#1*LAZrJBwJ`q8~!P;irt_zqy~
zC-)IS8HIk>ALwWIEkVhfZK=*QyT7>q5#-!rqn$Lnzq&=}!r)0rp*jc``_1hnC~>PT
zmB(7%<MKCzup0`^uMgyS^8}@Cv!xEB*>%0Of`Z#^bOX(<=UpNwV<R!Ucj3GkT=VmS
zYEC@P{z9(zv<M`(hH-7iVf;t*a$<Sj2ZGWHv7;S}dA|wDD)b2rO}^I%&#rg~y2Fm}
z@&kYhJieca7NgKa8tdxb{({m9y~p~f;Vl!CRj3<p3^l#ejjnCBt}ie;7c2DAMwdbh
zF^n0j<vn0@DfIJLpd#-Lqf4RN#{kv#{%v&KY3urY6j0o&F;McQ&|g`Lb-Z?h(hB7f
z)%Au8$|{tEg^AVk4iOaGW$P+L+l$rr))-w1^~eWm;9Y2RDO7{qv4-AOqe~$UNX8m@
z&lp{I+qx3tfEs%r8eIyVMWfcl+hcSo^kE~Qre0%=PoqsM)Qk<cnb%uTu-(=*pEri)
z-V{Meg(go1+Rr;&P+Fl5je!F145Le-HN0E5@UAhs?y+^<L|rYt2aPU;X5tw)*2?3Y
zCN5)zM)Bfr?R{f(DfB!qqBdSls6?B;*VeU>S9n{my`ZE*wP}Oec_Rd+6&lVvO?&T9
zL0N_FA?n~AXLQ|X>uQkz>gZi$bSd<c3)IQG!{}0IDWy7l&l+6{y*~n|i}#VyMN5k%
zPmIG8yd1iE4s15AWrb?+BI@Qf5tLTQN545%?DY|pRp|caK;6Bmf`a>PU1zia>ftRH
zlvL<VUduhbGX<p;3TOd(dDjZcD)bPa3wwJH8C^SVUEMg6(8qhz=u+qbTARM!w?>yj
zJ{m==pI3+;JKDUB#O!v!dDG98zjd5=d$yPX-cS(;9tcywiRySQ-bn^}a|C4+x}Iit
zkax78<b$@<l{r9zy^VsLhitTsW_O5ptDv+(htcc~^_~)xc-WS@gcY3d-V>BnsALk*
zFz**ZsYh%npVnl!*8pt_S3<@{YgttzydHuw3dLz?MtYM3B_Fk=&Y-SQ-V#C1V>a?e
z1C91h6_i%!UE0<$-c^DUkK0nsiN<>O3(6{VEY0pX?=?ZGCv2%UG`r)yuLT89+Grfj
z?gXy@=g{?2s1?obM6ZpY<WsiPSQgYIFCobJtBq!|G$wlo2}&z;HO=n+-Z6p_Puo&I
z)9g<1HVMiq)Qe_!s>ePAy6Vr^QpeL2PV=Y)_4TZcPN&&Dz<Xa%Mxg}F?sV^0LCNQA
zsq<kgVh4JhB*mQ1^EP^fx@LGi1*H{Q(FJIxH(5~P1zYOiW<ayNrGl~weZY%ows)GK
z)Qh&%jRDXc?`lE8OEzjxvwM)YQ&2{s*|e<(d#?*h?y{v`AUed`Ey#J<M*Yz!VuyOw
zVJvaaP$=#J&Gp&}O1xrAolL2uH%w4gp`UOrHqSd)Q0i4%>K$H{hk3^e3SP5OYnt8p
z-UWg(3N@kGUEtj=DEYcA^>TBdh2GPGoHuNARSTd+-Uoux3hm~#yx99qP~va4R6m;C
zC0-*8uEP{6bT@6(Qm>bw)SI@{7@FN>-u{AuzuV|ln%%>_Wr8vaHKEyE?wu|u`IaRm
zW;c!VVsLZhZ_J4gVT)Pe@iPu+oo|N%>v0%wL$iCN_p*sgp`A3lCEgc;G78mW!#&E&
z8^s8NckBqCqS;;PwG@<6XbsKoDsQl$tU^UofL4361SS4qM>vWFakRHeP+FnJv?j-R
z8w5G;+EN#`0Xo*ZSx{1;C-`u;#(P3gMxnbW0UhW4Q&8|vJHkdZyT^M!2}&vSAKKOv
zym|<Mx>u+-(OR!qP$FwbxPfN(L~nwiv_gYuc2Dva33A@ErQXJvL~NaRvY@0w19E{<
z-ey4=h32xLPWJ8-6wtO|$&&`Kf@b#=?-fBQh3=)<J=ObCP*$P0ImmFD7sGXlht?15
z2q&}zI^Am}D6P;Yn!+=@A%dI_ZK=&PyJvc{1tk@lNwa&Fw^~p}p<QgEXM5)h3O=$U
ze1p2yd$$NmDReqp?>XL+g0c#&qS-yy%L+<-Y)9C?J<xgH&w|nlJsbdS@an@9;rjZ-
zmKsX4d%o9QP*R~1+SZNUL_ryaJ|f!WEfy4fYDYLV0d#?PilCH29cgwi^sW??Rp>HG
zUF7W$l=zn&VI0?Y>@VJ{g3=0ohrGrv_P!G2d}d1x!nxQbUOrk+zMoX6C(Z7qUTZ-a
zh5kjedzm*>Q1H1O;k_+@F8AgLN+}d;3v`8dw4kg)Q;0Tu8wDl4up|7kBhZ!Jt%A}D
z&8-G>mG_h&=Sy4ab6T6Lz4rtq73xW|oA!PYl(CVR-3H@Bvul3$;5qT>G`rV&T>xMu
zzY5j3IE)XZ*}cviD=4WDKTHz4-kUEdtxzX6+#9@;1Z5R^hh}$+cbTBzYg^X_n%x_{
z?M9bEZE1FI@?J8!6uOe8@MiBbqf4R9O@VIls=+)UU%PExx3mGe)e8hA70PW7belI&
zP+FlZb=~gG5R_GjmNT~1JId(#x2<bSJ)k?hbB!*ACerL~^KLY{6uN<C_fGFIqf4Q?
zX=v{9{$X@|W9#~cX7_IIzeblrQ*(i~dv!3vhklSk$Fu{w$LlI6tI#!wJ$A1*PEhcz
zt?LCSiQVTd5R_Et8=Bo6-a4a8p%Z9!@Aob@x)f^7g4*fbV|0CI>$;m}_W^I0(WTG|
zmd1nL=SG)853#rVke7>U!wpZNFRKGR?6nXS{KwX{xeL%E-XK9qh1S#TX1tk#(h5ys
zvw758DJZMZ>omKMdHiY_+Tr)Mt{F7Dk9#*6T?(B^+xmp}xY4E1uS8FJ?;2eSU0WOI
zDep(4>jzucaGKq}dUa8h`F>KNJ85>G_PPm5E7Xx@_Ze@zpsYf7^ZI($TPP^_udQo3
z&F*tv%IH#P0?qF8-W5idLhgP*FL?JFT?)O}0_a8WWuxmyTi0R?bH-lszA(BJT0*nC
z%gfte+Pp&5Isv`xwG@<9=vZ2|SG>W3f}d<%KAX*}-Yh{$g(lGKzUHkmx)fSg3+N4R
zgP?4L<PF`aG_Zg3ZWiSH9O@GENmrmZy(a_(3JvQ5^mp%{f)WaSLj(Jk_miNcLf6y4
zzU|e6F~x(XLW5{v-|>nCr4@P>O)2&dZ-StVLeH@Qyz4CzlvU_a8rXk&Ckt|ZvGer<
z`?Xnbv!FmD>Uz(+Pf$Xk=`^tKd#?yeDzuw+;{)$YK`DiLb^!X&i%pdVpwMq@*dKYV
z1Z5O@mL}z6Z-}6*LiseypLnwcIef&%k|*`Gga-CgZ?&L6q4Q{9|K*)8D520*xJ}1C
z^KKE8ROmw**w4Ku1*H^vurAOSURF?Ap*v_`zw~|<lu>9P3+gMcKH357p+e8%>WO{r
zbr<CPX6Ng4md0+6a{w@33cW@H`)_ZtpoBs>HGsbHP7#z;=x(;&Z@nu8r4+h`2KGB|
zhoH1VPYeh8kN2vej6z=oK;L^`3Cb#TL=n&rUOui0bb0sK`MQc$^uJzfL4iW`4g~tq
z8!9NF(9YUGKY4QmB^8=O1N*agw4jti&m@3;@iq!dD>R$!@K^6vK^cYK=k@iQ$46Dv
zmqN>FVE1_M35wj0ns)dQYuWLC5fp^J8Vzbh1MB(?kaIi^DfDp*AkXh1D5=o?Xi72P
zpCl-yP>KdN$6q2St<ZBhK-K(H1!WZafGF2z1t4Dv^`wE#^Y0hrxTte1Ch_xWU}OGk
zf&v>!zxHdKmw^QHsu+G4aRcpmfnN=kiQGm4e@D3ZHg>$K`+=a8LhE=Vui+0Alu_tW
z-f3$3GXyzam^g{>qPjqZ{!vDkLbvfssO6t)bSZQqE4awN(dbgBbvK~e{$oa$Z|mya
z87S`m!{}0I4o1IYb^QMtT?&1Qt0Pv|uQP+Ckx}RcUL^JWu7aE#Ti0(rfa?3>1SJ%z
z-xH{Tzd%q*p^Fejtf9Zo=u)U|6QD-^<wjRETh}qX;WhT}F}f7GWfV{of0xmv(6hV}
zn);s`T?(zO57f-h#Y8hM{#;wvoxOmX`z-_|6x!S!Xg`0Dpp-&wU7*09DJY}RfenFL
z_$!UBJX_aj7F0|BJflmY=V|?0`8OF|3UPua*4lsE=u(I;`p4S%?;2e(Ti0i}Tw-ng
zAB`@B_=&?<JHPHMmPSe;cJE{D{ceIX3N>S6>)?+U<mB7BCa__5^cM<BDD(o2S|^{b
z;h{^RX9ogx_OCFy6uLhS)WyHo=qj*vy^VudSN~<BOQAuuT;2RHj4p+KWs55I^JYt%
zS7;@Rx4Yj`kW<~(^-}_<hd)?QLZQ>x*n0Z21f>*O(F&-Szsl%R==zR8z5NYFR}EWN
z2^)4F|7N30p(A<w@9RHdbSc!81=Y|0r_rU*&%9gr_kS|FYTCMvU_lM=>&;<lBoz9I
zhG?K)EGVVWOr~&<KS5B&M)K*(MK~{JH~J)E{IdZN81AnXflniWDL9N5vX?Q^zeLb?
z3enETM*DXOatgzAQ%cmlfE`g2eKjmzz;-mw|3CzSNZ>vSz`{Gfl@mCeJ;?EX-Gi9@
zl1SiF3ao)ZH=Gv@W;nXG6Yoe3ll@U5kd6cz;ZQUr%L$xG4g34Yh(J&j=3zVqs9{qi
z5PfkXK7Jqs4)AXjfm9@L0tJ|d$I1y@M-9{cH$@;(JJfI+1*qZMNFe$>c6`}D2+Z>H
z50(ot68HxNsG&8^OQuT&9-)TW{s0jO;-Q8@9EyemwE#wsy0T6W@(&k*WF#<@0@QFu
zIe{y3A#kw2Sp+hXKnVqyhx;OdJV_Yt<LjA+r2m2lWFvuVC_oLLmJ?V<4fFipL?EaW
z=HV3_##giJG2d@=h+G2^VqEe2D7C=vB`6gkN=dr*$9YLn=`Vn8VY-(13q>Fu3G~OI
zq$^cU;9HjMQvYHR*c}Nh!(p5c(Xqq*I|T)G!z44VI6rqATkbzEs3by^l5~B79Z6T|
zEAnUaiY@Vf6@hdl@G=EhUJVcZy#Rld8#~JH3XtzV9SL|ij6c&0Xq7)sP&Pu0EB+k~
z-fDk=pjf>y$&`|Gt;3F_tMnbxS9xPy<Nrkjf=FN~1(>dF<pj>8hU5IFL?Br|)NnZt
z<A?H|dV>F+piG1qSG;{|ptb%lf*ekDV#yP!4|%&i$!{>18BIn=q%LU$w9fA#DBZ}C
zlH5$fdC5)bt66=TLf}+?z6dytLxH|Hl-!(DPGAK)52yJTiNKUdU<n1-?(c{MjD^En
z2s5bRO#ev{NJRpdQGn%@Ehn&^8qV^+7lBNZFiFo+fEsEi!#o%bc~1OR7S(#c9YDSx
zGz|rQjx-D}C-8v}fph#>B9M**I^$3@tkMFgjDrdwaGrm*2xKCGLny#JTwhLLT0IDC
z@OO&9u1H`51(=7|BZ1OM!x|$Xu*v^i1hSF9BNU*9+<9T9O9i&DlrHd_0$?DtS(xeF
z6rhH_S|HbnKgUwK$e$zv*+`%T4n@O~asqo;N`LWB5`k3nP{T9|P{U=BK<Nm4yD<>B
z+`mHvGLgWk6kr~nEhq4p3xO;AtOykC7i!p!!}#Y+?Unw|f)Wv8T=6D3Kv((o4`a?Z
zMu<|9uI@N5ZQP^_miGkKUfLfc0+~pl2@WM)hm{jp!P>jVUn2s$BY}xHjL&5rulFw$
z<OIW!FI<*ldEa$`Zt%AXN<>KPb@ettH~P;AN=8Ve`Z6~+`5y{OM@XcuV7hPd_Xx^F
zNTk*?g}3^R=d%o)7Q;<4O09fvoVTng%7D{Uv910D5eOoI{ctE{u&A8C5e*@5hrd<?
zN+N+NIE=4n-Q4M4A}Adp#ua~-gCckNcL~}ZA(7fiTesbRK~T^#OtMI|rm4Tj|5Q*(
zgeWD?#J^%ka?{9(=QHCw{W=Sz*+)UYM2L7N7V-mrS3%hb@q7Al4hY2_^2Z5sT7|kr
zYFAsJhy4YD5)l%q*$|Co{B?qo5fZ7zya_z&UoI#eAxcS#@4$IUaZM-wRb2#q(tlEd
zW}={1<1qf>P@t#$te|%y#3`xxtCV`$|5?!P2#M5PlzPUmzmP>xqji`Wk$Rn_^PJyZ
zP!J)J8aoW=d4HmyK@p;qG=Rl8FDWkV0Cye%fmi$!MPPg+FcpXK(L}HLmkOE^A@)Jz
zNuoFWy9K2p#Li><c%nD`7X@V_#9m+gBBHnae+dfOgjr&DExwiL9Y1Fgb2}wMa((c9
zlGwZceu9z_l8(rxzCc-jfS{ETlD@#-`PA{gf1sdLgyhD`F}K)9eu<!65#qfq&L3pN
zKK9QM<g^V_$eU8U8xCTh_*(=eBScFaA4l}5|EQpi5fTG;Jkh`WcLZ&VkmPGRADKS$
ze-M<35HE*1pN~f|v>J`ez3u`eHox_q*oFNMoijPcIZhERk#UZ*36Iddu>Ri5&j<N%
z*YT%woIjo8{QuH9&W&jCZuQ@{`7-A?)p2Q+I>)Kb%c;ycPEG9`r>=62Q(rm9X};UD
zoa5~GksO82aRSRZPUsLvoZ}2+-^tq)I>#AojzZ@+L)cCFA99Y9=>h|TrE=#uyQ7em
zI>(814dX259H+J-wsV}uigbq2ik#!LvWeV;p2;b_(JSXT#ZgG!V3l*6DT>(6aY}3=
zu~+0AXMGg1oO7IwirCI^E>^^Yy^WmXY_^H$t;jjfwNXgkgq3rgZHm~=aUQmb#9one
zoLy1Ka?WvfD`GpxDdMe6+6+@<JI5(j<kGgtZ|EFniXygioD!Qz*Zk((uzuml$99gB
zjzV6B01~ny=Qu%en8He(<0PVxl{&{sMj<P8j+2f;R_YvQTNJWV=Qx=tWTnn=g6?77
z%Q?rH5|K)s<D{aHl{&}S7KN<TInEPN$V#2#WTTMfoZ~n>!n_Hwo#O;H*{5@yL=>`|
zbDWeSwsV|}O{D9-Z|68p&oG_koa5vwGKupIp>v!XirCI^;)>YLaT+ROJI86Ri0vGw
zwIa52oQ{gv&T)zrv7O`eQN(tRGe{BJInHoJZ09&*6|tS;OxA=?ouPA_>5ACSapovu
zJI6^XVmrrKq=@YtXSpJ_bDWim*v@g*C}KOuIY|-QInHT{*v@g*D`Gpx*{F!^9Oq(1
zZ09(e6|tS;T&sxf9OouQcHu4^Img+m$Wbwn&^gX_MQrCdI~B2=<75=Eo#Q;Ei0vHb
zc|~mJIIk#TJI8rbkpTC!$T`ltirCI^K2&6-2bs`0&S#3)&T)1tVmrtAUXiC-BDT;u
z&M%7C&T+h6wso<c<HQuPo#PZLVmrsFtBCC!r?DcobDTgC+c{2KMQrCdooymEbl=W#
z5>fba&T&$T*v@e>irCI^oZexXNo=-roP;8_bDWeSwsV|}BDQlJr;n}2c8-%!#CDF8
zQp9$SlTpNWj^p&T_1MmF5{lT)aZ;MlhK9~@GK$#Fah!g(9@{xiLJ`|JPD&BmIZj3q
z{`fj_j^p&V^)&7X5<168C}KOuNhxAG$H^#SJI8Sb*m{oSTLPhToP;8_bDWeSwsV|}
zBDQlJXP~Xec8-%!#CDF8Qp9$SlTpNWj^hln_1MmF5{lT)aZ-xd&T%q|*v@gB!L}aT
zIZi^6ezc*XbDWeSwsV|}BI`ZKgwAoCA+{ddIZi?m+c{23k#}1nw$M3FMiJXNjx*HO
zV>`!5C{oA)*3dalN)g*RPDYUfe8_~(ah!y$$99gBP~?OjkO`gRq!el003>vdld*}|
z(0x0{afXH3%Q?r%C}KOuNe#DUZ09(M5jL@%<2WO2VmrslC}KOuNsY2)Z09(M(KfN2
z<2Yk%VmrslC}KOuNsYB-Z09%$j=N$pj(cq9IL>&R*v@e>n$U)Z&T&!`Y#G}*PGX`>
zZ09)6B%9dIaWab7&T&$cZ5i7+PGWzX*v@gBDK@d4<75=Eo#UjY+A_9toWwMn*v@gB
z18ibD$H^#SJI6^)w`FYSIEe#oVmrriX4r(k(u$npWE8QT<D_QVGEO06LgzS%SvIkq
z<2bWzVmrslC}KOuNzJikZ09(MgKTpCen>&+9LG7>CU~{G)HzN@5!*RV>JVGzS`RXz
zbDYGXHnE-KICE`cJIBc=@_kFh7COgCC2bkoIZk4pO>E~l&S5sOo#SK_v7O_j=G!ud
z(}sr5aS{t`Vmrri7TUyij+0Tuc8-%;WXXsP-M4d`#Nse~Ip;WOMQrCd&JtV3c8-%&
z#CDF8QN(tR6D+l3vz_Cl6tSJ-WEFXhJ+06=PGXrIo9!GYt%&U$$2r`Vv7O^26?v~c
z^n}iFGK$#Faf0P`Y<2lAO6VLXrHJhuC##6<94B#v9h>bOC#{I>9LHH<%h=9wl8V^Q
zaWab7&T)bx?bvMRI4MPJ=QvqKZ09(M5<52AIZj#;+c}PNlr3XB$4M$;JIBc=VmrqP
zR@$-I&T&$T*v@gXirCI^607XkZ09&>MQrCd&T3ocZOptx&T*28*v@e>iY%cG4V~iz
zN87R4&T&$T?DQZLI>*T>Vmrr49An33JI6^YVmrrij<scM=Qv44Z09%`MQrCd!5TX@
z+c{235!*RVRuS7dPU1K_HrqK)S`phhj&r;vBQ|v3&T*1a_;Sv1GK$#Fae@;<9U@~p
z$4S{lJIBc?q@3d<)>`q!m2;f5LdrRgbD}M!oZ}=FQqFNQ3MuC}!AW+6$~jI-A>|w=
ztB`VzlUQd**ooFOa*mT$NIA!GQnr+Gj+0bKImgK;q@3dfC)*J!=Qt^alyjV{LdrQ#
z;uJeV<s2uikaCXWoN7xc=Qv4)lyjVnLdrQ#aGD*Va*mTyNIA#JDx{p_Bu=*@e3>Jq
zk#n51LdrRgbA~OYoZ}=FQqFNQ3MuC}!I^f1$~jI-A>|w=t5AwYHgb-WILnSuImbyW
z^oj?m$T^O4wk@Tc<0KVQ&T%pdDd#xBdOJep94Doaa*mT#NIAzzoMT6*oa3YwQqFOl
zb8RW*94D!ea*mTxNIAy|&a)yElUs>%oKz$rzt>dGancGY=QtUKlyjV{LdrRgvms2J
z=u*yc0)>=woP<KkIZjfc@m<kkBIh_Mg_Lugv_cJ$rc&oP8HJQ{oUB61IgWF_ov-1O
z5MksTCs0T^$4MxpoZ}=FQqFNw3MuC}X@!(?oQy)sIZjp~<s8S^Xy;2g#|act&T$e7
zb!v{%h@9gj6;jS|QVJ>OIBA8HbDWGq$~jI}A>|y$*<|NSImZbUQqFM_3MuC}NrlcD
zi7ZFXaZ(B?=QwGF9KJ~yImgK;q@3eq6;jS|oD1xHT}rbXImZbUQqFM_3Vr55DsqmK
zR7g3;Nhze9<D?Z*&T%pdDd#v@g_Ls~=R!MQ$~jJ;kaCWbQ0Q)s6hzK(k_sv3I4OnR
z=6Gx594D=ia*mU+k(k{|oa1C8f%49Af{Vi33R2E-k_sv3IBA8HbDXR~$~jK(7h9Kd
zj+0bKImbyWq@3eq6;jS|f{Sfk9L6bij+0bKImbyWq@3eq6;jS|f=g^&$~jI_A>|w=
zt&nn#lT}DL#|bXAbt&gKNrjYioU}s9IZjp~<s2ut%+{rx<0KVQ&T-NTDd#v@g_Lug
z;Bs4+a*mT!NIAzzE2Ny`WEE1*ae^ysUCKF5QlTUVWFzM|X@!(?oUB61IZm+I)}@@|
zBo$K5ancHX%~9FNIZjrgZ8W=)bDZExTbFW<lT=7K$4M)soa1B_QqFOLt887$IZjd`
z<s2uikaCWbRcI}zxFY8`!PT}d<s2uekaCWbR!BL=$tt9r;{<72mvWAiw2_$IN}S_t
zj0DO%$JwTka*nf0A>|xrw?fJ}PSG`Cx<!|Aj#I3Va*i`ap;RptdgL6ZL?PuIXQM*O
zInFkPlyjV23MuC}yA?W$QzwygoT6*(d@1KR#R@6sI8zi#*F=PobDR=|lyjVo3MuC}
z+Z0mHads(m8<Jb<9A~#ety=&^&T)#av-35?1&W;G6f2~h<4jRVImancNIA#ZsE~4w
zvrQr89A}q8$~n$%g=%xSAaagVbiJLgAOMP-;}k3O{#c;MInES?zQ(JxrOt6m6jIJ{
zHY%i?<7`t%Img+hkaCW*TcM|ETO;Q<MK{>_QqFOT6;jS|rYNMG<CG|*oa1a%NIA#Z
zrjT-uvr8f69A~#eb($exk#n4)Eq1<?bDUy@-b+9#a*i`aA>|yWL?PuIXQM(nEfHbl
z9A}$C$~n$18;RMi#5s<0W0<A#&T-NTDd#wen`|lN94D)ga*mU_*_Kkyae`ZHq@3eq
z6jIJ{lDFDY$~lfh+kz!e@}->Pq!m)maT2%NQp!0_R-v<Lb|dFFsjaq@a*h++VWTwx
zq$1}y8HJQ{oa8oJN;$`I?zE9|j+0hMImb!dWlMdBgHq=>S%nUy*^Qjzr0%w*X3*?L
z&T)e6Hd4-UG72f@ILUi#Ddil;xz|R@IZj$3<s2t*pDm@F<75?5&T&#ZY^m9-lrKZ)
zIKllkQqFNQ3MuC}$(^>8a*pFXU?b%mC#{fjj+1!MmQv1fvI;5ZIH`whDdij|c-ThD
zIZj3)<s2vZh%L2)Z9a02<78~4oa3YwQqFM_kJ?hoIZjp~<s2vVm@TE8;{=b}s18#Y
zImgK;l*d|*oZ}>)u%(o99Op?J{Xguz3Ai0qmA_s0-V8SkF@!;8icv%%10f_bSj;no
zK?NLAKoW>Ra?OA^7vg}57!+GtZ7Bzwhd2+=TH0#k92L~I9m-Z5L8I-|DEi-3wbr@o
zUHcsF{kro!&DRg<HYD$F@3nXBQ>RXyb8hx~@jjuK%5h3WkmF>ZH@(`+?gVn2T06vY
zob+F%RvST%lOuv0r$hufPK^k1ob(Pm7UVcNBFJ${M3Cduh#<#FzhK9L94AKvIZlZP
za-13w<T&XU?O2fG<cJ{0DG|*KKMC2B<J5>C$4S3r$ATOuM+7-ei3oC>8WH3;>6h(T
zkmKZt_Sh#(UgbC?BFJ%SM3Cd8U$J9Bj*}yT9H&GCIZllTa-8(5b}Yzoazv2hl!!Jo
z&v2FF)QBL*Nxx>tf*dDD1UXKLXzwhHrE;7a(S6O!q{?y9O?Ir6O)r(><cJ{0DG@=A
zQzL>LC;hq|3v!$s5#%@}q8IHQW~g$U8WH3;={M|HkmKZtAjc^Y%?bbZuqVf<5#82o
zh@o<v^qY1p$Z>KTwU^xq<T#~vh~+rhoia=tL5@=+f*hx~%l3jCC;gU<Ajhc?L5`Du
z+xCJSC;5(zAjc^YL5`FCo9zWTPK^k1oZ`E-7vwnUzuO3MoC*=-IQjQ%FUWC{@7oA+
zoDvb_IN1+uFUWCfL?=HYoJ?nk9H;o9?FBhbTH6S6oC*=-IQfrkuLb*ru~d$e{D+Mo
z$0-p(j+6b^_JSOzMg%!d@e|t%a-8&T8$pg!A%Ywy|EcW-IZpC38@;W$?5Z56L<Bib
z_H)|{a-13w<T%AIY_G-51ytoY=`U?GdpJZY$Egrq)AUj~PW~&~3v!&~9veZ9QzC*K
zC%f17+O7FkO652;BFJ%yU)x@9XfC@d$4P%<Bgk<oM2ijxy;P2qZ??T4$4P!`Bgk<|
zM3CcTzq7p{$Ej`9UUnyt;}riXwPHC=jR<m_?Dw`8<TxcF$Z?WC*j`tk6V^!OI5{H7
zaVkWR<D`GI1tG^N5J8SpBZ3?!`;#pQIZlZPa-8JPwio0$IU>k$DnyXur2l0LLXJ})
zf*hwt1UXK2pDhSEPKgL|oa8UI7vwlOBFJ$nM5pZ&9%Yr|q<^&qA;&2YL5@=+f*dEi
z-xh=%r$hufPVzU~3v!$s(c0z{MwR1Kh#<#F|85I@vbpT49H&48IZllTa-1wVE@^&s
z#v;gZN<?R8VJwy7Bty2>LBk<ZIZlq~ADdn($EgrOj*|}Cf{^1Bh#<$Q5kZcVjo5;a
z<CKU#(p+{`j+0EWy+)gBtIBb5M3CcDh#<#Fr`m#$;}nP>$EguPj+0F@1>4K+1ah2G
zJH&FF8d0+`Nl%WGPM2ZYUXbJDh#<!)5kZbqBZ3?!9kpXYj*}yT9H&GCIZllTa-4LA
z9Sd@t91-L=B_haiYDAFZq+8jsAjioOL5@=*f*hwt1UXK+wH*s`oE#D4I3*&;acV@6
z<D}czv7WV0IBisplOuv0r$hufPK^k1oOD||7UVcNBFJ${M3Cduh#<#FXWFqK$H@`h
zm4-uBIZlZPa-13w<T&ZW>{yWF<cJ{0DG?ppTy|BCQzLqRbJ<lnPCCnu1vyTR2y&bf
z5#%^EBFJ&l?d({P<K&1S$0-qAx;RW;<v2B>%bF{)%5l=!b}Yzoazv2hl!ze5sS!br
zlWuRvf*dE;sQsx~$Z-lpkmHnyj%jw%R5?zC2y&bn5#%_@4l=`b8j$0ph#<$w5J8TU
zBZ3^KKm<8X$*B2RTb1Kfh#<$Q5kZcV>}Zb*a-0;=-<lumR5?zD2y&bp5#%@pBFJ${
zM3CcDh#<$Q5kZcV>|~GY_U5N|RF0D(dS7#aRXI+E2y&bp5#%@pBFJ${M3CcDh#<$Q
z5kZcVJlq}^<Txp!=IfW994A9`Pji7)IZloUa-0HD<7Vl}aY{sx<5Y+s$Egur*j!*$
zj+5+ckLwG~1y<!aDI&;mGDMK$<cJ{0DG))9QzC*Kr$PidPK^k1oMab!T#)0Wh#<$w
z5J8TUBZ3^KKm<8XX`}YOb^<w0r5$29PO_^UQX4^zlOci}r$7WbPK5|^oMbmU7UVb?
zBFJ$HM3CcDh#<#FcDG|ej*}sR9H&48IZlNLa-3ujJJwCjb5-Ry86wDW3Ph0OREQwQ
zN%pj3L5`Clf*hwn1UXKH2y&ccFFO|GI2j_yaSB9`<5Y+s$4OE<7UVb?BFJ$HM88bJ
z%BviwLIgQZvbP-za-0ki<TwQ)$Z;w}kmDr#*s;ENM3|w<aWX`Z;}nRRF9~{boC*=-
zILW?tEXZ*(M3CbYi0*4H)+)!T5J8TU>}SVXwQuO9a-0ki<TwQ)$Z;w}kmDr#+p!?W
z$q+$~Qy_vIr$PidPI7=93v!&yM(t*t6UcEc(+;s5XC0z&-j2(03LCY<Od!W8wZmlP
zIGeS@WaT*NBV<t~E5|7hln#@X<0Oxi4wIGRRN7&(a-8HK8DX+=oKibXR*q9^hsnxu
zvPa33CM(CuwL_yiXg9f?K#o&thj#mP$Z;x-T5SU4ILV`BUOjEX1ah2IJ4{xNGo~G4
zIZmljEXUcb(PZT~>A`X!la=F~tQ}%GPOecb$GJ|U$;xp`?J!w6PJM_RNG!+6=13IF
zaf-RN7vwm#MzI_xoo{-z*PjXGIE8kYtQ=>Pc9^UjCplE6G+8-Lwm>>eR*q9@hsnxu
z(!*qg$;xpu?J!w6&Jyi#LoRziPawz1wZmlPIO#$;hDOQIKGGA&adPc2SvgK}xQsAa
zIZmb>CM(C;pdDg4PNh*S$C<TA<~3P4PNp4pyI8Kg7l%KzUXY$m2XdS-?QnW%M>$TR
zQG4Zu9H-K#y<S6(Q)|@rf*dDZEJxG!f*dE)sO<$gPN7lnDu37|a!5VJD&#n&cGxSl
zYhQg<L>(Z<*{mIwgm#qUq>nkSx#>x!H?=6o8Pllk1vyTsQQHf0oXr|Fz1sK0_lG~U
z50IDRq({iu_cmigj+1ND?59sTPN7lT3v!%Fqqf%tp=(c$Q)|@rf*dD3Ql`=LYG*u9
zj+1HASdQ}~jhe5dD90JoD3;?~uTk3za-345SdMeMMoq8w1eidM^F{3t%W*bo6w7gv
zqhw)XIZm!oEXOG|isd+)G-{t8cZBLaIZmxnEXVnsMzI_xIa+2I%W;-y6w7f6jbb@Y
ztx+t;ne|v1E0*KT)u=r#$Z;}_ny14g<v8hZSeQ<ZbBD-r-ncqzpQg__yZuk{`RyN)
z<0L!Jcu0=(e^QQ9w{jeR&Tnx!&R(0t6K(j$%Vr&OLXh#Kcej5NInLgHY5#Wqc4s6*
zhhH6@bi+5ca-7F>e-=5;k=@@!j&oG_EPqSMak3NTYIE;MxWqTZJR-b0b@w^RtXsmq
z9@DQlGLT@{)s_>=ajw&rksRknBvy{|S|nDE^Jbg0FG7RlI2*NP^8yPw&L$*p**6^3
zb7qIvv>79tZPHdBB*)q6Bw49Qjx!61mE-J$#L97Yw@EwhAUV!H+Ol~Oh8$-u5-Z0!
z+9qxFL2{fW+A@;kj3KddoDE2<9A_gEE63S{#L96t+oU}M2gz~LljRYZP>xe-%L(N;
zmA0Hvj#F#P3FSEHDKgIq<v4S-<%DvaOj}MU$0@aCB*)pL$%Jy8<WxC=3FSC*wdI6z
zoa43SgmRo*TSju60*RI5ls0)lIZmZ5BRNiTnjCeTSUFB+llIpAf#o=bwvXgEFG6DF
zIM*Ywa-3Hpv2vW7kyts-8<1Ez&RdXJInFzgSUJu{Bvy{|5hPZQb2}0%$N3BrE62G5
ziIwAgmC4TG&Q;_%cOtQJobMvBa-158mE-&riIwBrgT%^leuu=$asG_N%5naN#L97|
zoGxc!d+t~{&Q?gQ9A_31E63RhiIwB*j>O7w_CaFhI0quJa-2huSUJuDBvy{|7$jDX
zlOeHkoD-2)InL=wtQ_YYBvy`dK9V%t{iq!0DM+jwXBm<;&3h=3<2)6KmE(*dv2vWN
zkbHihP)+1G&qiY9IL}97<v7<Nv2vUnkXSj+O-POy2{U-YAz`PY86&SnV&ym`5-Z1f
zD-tWmdACj4Yv=>ZaVl*e$#If1<QdW?R*sV)v2vUOiIwA2NUR(uIn$0~<v1A<E5|92
zSUFCG#L97!v+Oulj*}s=a-0H*mE%-MtQ;p<V#oPua}5<aPKLzFaS9|>j#DAAa-8IB
zJC2p(WJs(Wr$A!mI295r$4Sny<5)RPhQ!Ko3M5vJQz5Z(oa9_Pj+NtNNUR*EKw{-M
z6%s4QNzSw5SUFCH#L96BBvy`7A+d6t<Z*T!E62%@SUFCC#L96hB#WABsK{}W$J=qN
z94ABa(&ic}a-0H*mE%-MtQ;qKf*t1v%{5fyI2jTv$0?9lIZlOSX7jU$BF9P2x8qnj
zPKM;%k<drvI0X_b$ElE5IZkqc9mmRXGMlv5&<B>|6xu$L<75}g7;R$ZILQ-jV&ym$
z5-Z0ko@D!2IZpOun^-wc@)Vm`IZlPd%5jRNwvUzLWVubO94EQRCRUD9A+d6t;$qv!
z%5kzwkTlm&k>e!GY+~g&6%s4QDVEzlR*sXcu!)u9B$wL6%5f?rR*q9#X8Tw<PPWn}
zR*sWA)h1SsQz5Z(oZ@oZ$I5ZCD{NxrILVbZv2vUWiIw9Nt85=D$H`XP#L97!F`HO9
zPKCtEaf+weK30yCt+9!f<0NZsV&ym$5-Z0k*4aK*j+3poiIw9dSJ~uE%{5fyI295r
z$0?p}`&c<ncC}6Z*jz(Jj*~pYCRUD9A+d6t;+eLOmE&a3vWb=BB+s_V<s)GRBFCwa
zSUFDd9NWjrakA&y#L97!=b5CvhCZ+yr_%P3949TLQkz&gPJzVAacU%1j+0$ut64ct
ziNwlrlIPn#R*sV+v2vUWiIwA|*V<}Uj#D79a-158mE&YDu+^*_r(|N}ILQlbA1lYn
zkytrSg~ZBn(ihokR*q93v2vUmiIwAIFSgaJ9H&HL<v7W8wvUzL<VdU>r$S=oIO$7l
zH7my{kXSiRjl{}vvX|OwR*q95v2vW`Wwwu%<K#%J9H&BJ<v8i}wwjgW6iBQbr$%Ds
zIN8f>wac3OP?6)5NUR(uxxx1NL~{)lIZlqm%5f?rR*sXt!d9EPZ>aX$tHZxto-tA&
zv2vUmiIwAI8*DWz$0?CmIZkq;?Q`u&n86?KYiE!nv2vUWiIwA|ue8;y9H+2JdkuYH
zIZmzZBRNj?DjB0qtQ@CAV&yo=O{Nd!I5{H7aVkWR<D{>)1tG^N5J8SpBZ3?!`v+SP
za-0$o<T%M|Y_I)B!lO4j^zpD;^Nf)k5#%@(BP+*AZ?**?$0-m&j#DFo94GrnTM%-b
z5)tG$$!l#d$Z>K+kmFQ{Aje5xXA44(Qy_vIr$z)hPWF0R5OSOn5#%_@KiOW8<K&1S
z$EgrOj+4H@7K9w9Km<8XjR<m_>=s)Pa-0$o<Ty!bdqIwqBPyDUtjcjJM3Cd8Z?px!
z(OhO#j#D6l9H&MEIZpN_TkwE=L%{=vejILEXN;7HAje7GY<oeDlOuv0r$PidPWl#G
z@O2|$8jl)!YM4#9;v<3_r$z)hPIjv;2sut^qxO>ftuRpgMg8>l_n~C=Pn!+q=MCM{
z&LDZK)T+W?XG4yYB7z(zLj*ZajtFv`0ukgmB_haiDnyXu)QC>Ca-8IC_P8L&NfGUQ
zY*>vWhVI+1c|0;ikmKZtAjc^XL5@=*f*hwp1UXKP2y&d{?e@4J$4L=Ej*}sR94AKv
zIZlBHa-0$o<Tw=~$Z={!kmDrpu*U^CPKpR}oD31<I5{H7aSB9`<CKUX$EgrOj#DFo
z94C3FJub*`QbdsBWQZWg$q_-0Qy{vzx$LSOr$hufPKD@~&1F~RI5i^3agul0<ANL~
zMRfGOq2LpTE<CV(ej$P!Cr1Q1PJsw=oDvb_I2ED~j)ZBb9H&MEIZpC!dt8v?q=+EL
z$!yeKb|;YI<k}&Y<CKUX$EguPj+4Ge=G_*A94AKvIZlZPa-13w<T&Yj?O2fG<cJ{0
zDG^=LTz1EXo_0`kTGWUj$4TF3$ATOuM+7-ei3oC>8WH3;=|(#i<TyDZ$Z<+UkmJ;d
zAje7HZ^wchCr1Q1PKgL|oEj12IOzxMSdio7h#<!)5kZbqBZ3?!{h%ESa-19y<TxcF
z$Z={!kmIBuvSUGxlOuv0r$hufPK^k1ob<zXEXZ+kM3Cc@h#<$Q5e<)or^CyKii4Y{
zL;4Xr7UVcNBFJ${M33J$6x=ZM^|oM*2y&eCqjoIFadJeE<CKUX$Egv0sX4A!51k)w
z&BAeg%#H;)PL2q2oDvb_IJJ%1%kBhnoLL{28N_m&xriXgS%L_1oH0a@<7_|#InG8z
zkmGDZ1Ub%TM3Cdm`h-0$$Z_T(f*fZFBFJ&Z5J8T!0TJXl8xcW{vk4L8IGYhcjx*~v
zdt8v?%tZt_&JslLZeD5LJM`~!n^SNM5#%@<5J8T!5fS7#n-D>cvl$WOIJ0iI#|1gg
zTttxLEI|Z0&KM%daW)`I)36#U$JvMoa-2<welsof`oz#)VOQ4h!_bHz$C>rd_P8L&
znTrT=oF#}L#~DKeInD+|kmGDb1Ub$oM3CcbMg%#|tWVnGf*fZqBFJ%;Ac7oc3=!lw
z8xTQ`vk}pcvhbj&9A^_E$Z<9!f*fbor|fY}*(VfKInG=}kmD?|QG3~)K#o&rhggo2
zRx*P&f*hwp1UXLrY1<2Ooa8e$f*hwr1UXLjFSghB_6-a1?V*{6HK%)x2y&d_v$hxH
zIO*qX1UXKH2y&eK^R^e{ILW`-2y&bf5#%`89kv(bI5i^3af&b4UXbIYU$hbAI2EF1
zXW^b4C;yV|1vyUgWg9_`QzC*KC;N)+1vyTQ2y&d_tF{;9IO*4H1UXKH2y&c!lkEjL
zPV#jdUC>;1?-e;ti3oC>>>IWh<Ty1V$Z?8q+Fp?3q<7i~a-0eg<T&|Vwio0$$+v6-
zIZlZPa-8hjwio0$H6qAyitpH7kmIEPW+TXPDnyXu<lnWuAje7m-A0h(l!ze5$-ZZM
zO>Z7$mE+WiAjc`bZ+k(Glm5U)kmFP~YA?GJ$Z_%?O08IqQzC*Kr$z)hPFmZ7kmKZt
zAjc^YL5@=+f*dFPksS+ioE#D4I3*&;acV@6<D~y#$ATOuM+7-ei3oC>8WH3;>5uJL
zGs90p_T)G@BFJ${M3Cduh#<#Fe`3di94AKvIZlZPa-15`9?kuN%5l=W?O2fG<cJ{0
zDG@=AQzL>LC;h1%3v!$s5#%@}BFJ%SM3Cd8KeJ;&j*}yT9H&GCIZllTa-8(%cC5Xd
z`#Y86<cJ{0DG@=AQzL3l%F%;|?>?%1GyV%Z7UVcNBFJ${M3Cduh#<#Fe`&{p94AKv
zIZlZPa-13w<T&ZC>{xTczlQ9|adJeE<CKUX$Ej`9UUnyt<D~b<3}QJ>g$Qz-{9fA&
za-8JXHi8_dL<Bib_8Z#^a-13w<T%A<+Y54>^tU#G9H&AAIZpmN+Y54><Uef$IZlZP
za-8h<wio0$H6qAyia*$1kmIC(v=QVu6(Y!S@;}*LkmDqOwh`nwB_haivj4KZAjhc@
zL5@@0XL~`8lm5j<kmFQ{Ajir7YI{MBliY73$Z<+UkmF>3v%Mh4sS!brQ~cfbdRud2
zrE;7!IX-EAO>duHkmFQ{AjipvY%j=hl3^P`j#DCn948yGy{^f^3{{R(BWfO@(Tj$k
z6#f&w@t<OQL5`D7wGrev6(Y!S@@cjg<T%N68$pg!B7z(z8@0V4$EguPj#JFAy&%U)
zx3UrBI29tuaq_KAulBM#fgC5<MmofDoE#D4I29tuanfyVLCA3mM3Cduh#<$wX4-;~
z<CKUX$4MS$dqIwqBZ3^KLIgQZI?EP>9H&48IZllTa-3{CTM%-b5)tG$Nn<Z*p2qFt
z1vyTR2y&bX5#%`O_O>A8I0YieacV@6<77M7f{^2sh#<#FcC@`9$H@^vj#D9m94Fn$
z7K9w9Km<8XjR<m_?BTW`<TxcF$Z?XLZ7;}iazv2hREQwQNq4aY&u%WDD#s}hL5@=+
zf*dE?)fQ|{l+jlYfAi$#vRfj894Fb$_JSNIM+7-eg$Qz-baz`2a-0IuXrp3KIZllT
za-3`rTM%-b5)tG$$)2_s<TyDZ$Z;wgwU^xq<T&YGGE6MT$q_Xhll0^`B_haiYDAFZ
zq^TVXa-19y<TxcF$Z={!kmIC#+p!?W$q_-0QzC*Kr$z)hPP&gB3v!$s5#%@}BFJ%S
zM3Cd8``WP}$H@^vj#DCn9H&MEIZnEt9Sd@t91-L=B_haiYDAFZr2E^kAjioOL5@=*
zf*hwt1UXK6fE^2RoE#D4I3=Pb;Rm8dKRvwWjP^SQM0cejQaMig2s;+!I5{H7aY{sx
z<J5>C$4L*gV?mCSBYJ;xu~s=wiRhqEV)P5cr=Hm!7b3`U(ns2{AjioOL5@=*f*hwt
z1UXLHOe*}E-d>|1$H@_0)?ATQj#DCn9H&MEIZpa0I~L?PIU>k$N<@(3)EZU$hM&-d
z94C3SjMYYv<D`fn$H@>uj*}yT9H&48IZlZPa-0eg<Ty1V$Z?W`?QubllQIg=o}L^h
zLj*ZajtFv`0ukgmC8EEDIrZc?6(Y!SYDAFZB!}4Jf*dDB1UXKI2y&bp5#%@pBFJ${
zM3CcDh#<$Q5kZcV%(2G>IZlcQa-0ki<TyDZ$Z-lpkmHnyAjhc?-IIogQsp=`BFJ%)
zx%Rjq$4L=Ej*}sR94AKvIZlBHa-0&;1<iSQ|M0ucZ7#4CBFJ%SM3Cbo^Xzd!j*}vS
z94A8rIZloUa-0GY<TxdwFHH%@HFf0Lux(*DE<`_WqG=<|12AKxMg%!dGT$B-<T$B~
z+WXoG<T#mjh~+p1BFJ$nM3CbohsxyIf{^26h#<!)5J8SpA%YwySzyP494A8rIZlBH
za-0eg<T%M;b}YzoGDMK$6o??lsSrVqlPt7jL5`Clf*hwn1UXKH2y&d{a61;{I2j_y
zaSB9`<5Y+s$4M61u^`9E5J8SpAc7pHLIgQZve=FVIZlQMa-0GY<Tw=~$Z?X#*s&nT
z$q;=dv>ScYNO6Ai3@;Etj#D9m949%#js-bRh6r+;0ukgm6(Y!Sk|XU{_hn)7D#ytX
zL5@=(S`}{RdUBi!5#%_@QFbiIaWX`Z;}nP>$EgrOj*}d1$ATOuLj*Zafe3P(%0}(B
zofF7$ey$y2InM79HTUzQCyspJ!sd)g9xL;1dbPt$Aje6y!(`<+W7=V|a-32-OjeGQ
z9wWyvSvgLj9VRQs$&Qr~CM(A&w8LcOIO%aR!er$*xptVW9H-I_la=Gt+M!V$w42;c
zAje6Mmt$zRPhU4BoMxAd?DFL1G|Mz<wF!{p6dLuk2@}Y1O6@RNInHM75X*7W6J*M<
z9A`|U$;xp`?J!w6&K=qzmgCeK#d4g{6J^SimE)w^VX|_Z{3ID6mg7_!#d4hF6x$1O
zoLr+=j#Hj$dbQV|3FJ7*Y0_b`a-1dFVX|_ZLOV=Wj#Hg3Q<|(CCp|+tOjeFlYKO_n
zaVqUFSvk%o?QlabuLBdvacb=_SvgL5rX2KU9bp1FPOTj#E5|9$k`X2=$Emc#WaT)s
zmdFUP94FH#mg8*DXtHvgN;^zej<Z=i#B!YEY?*R<<%Jw4)2O{(LynVc)b=`jO1PB2
zedH$>H<$8KqqZ01IF&|iFUWC{b7UI5tNdY?JfIvW)ed`wcI~Uril_tRIAhvjNoYqo
zPN`8-i*lUJ8nwM3$4SqXDYv~K#~IV8>D9g`zF#Nj<v67_y|)<~a-3SDkB9Z8949$X
z#%_B-j+1HB_PQW+?a6U+joMz2<CGdTz1kVSZ<(zBw#n>YH@h%?Zsc<Tg-;N)=`G=}
zv%mV-5Pg26ZlmvM)O;mHInHK{+Fl=MdVOJJr{zt-Z60@gbI+MfZ+k(GlWNrVI{BE;
z>&qjjx4n+ksOi<7029b@PSp;v9A}9}u^gw+D3;^Y8pU#)^zm{?u^eZKM(y+Cj^n~1
z{a|FT70p8A8pU#)H5$cooI;~mj<ZRlSdNoCL1q}sadM5CEAi}8ntyKa^N~-tGu)t2
zEXUcXQF~mF<5U_oPlpNRICq9qVM;Q0Bn;chaYn*>*9AcpvgfC>5GBdShT8umFWoa}
zI7X-677k>1X!L+^jt&n`-|ErfKU1bxEu3~>3#TqRFG)tGOkKHZUFa}%`_tNfH$1B8
zH*HR6GUcWz;m`AeEH;_CRTyn(t1w(N-q7p66zH@Ilc8;zKaAX1Ja78>pUJ`>ljP~`
z?;%~849#ph58rr2IDoa`Pcy>lnuLGfwacZ=alK>wxaP}oed{w>Xptl;{n;jLIW+w0
z-NSGDEed#Ks6C94;r1}5bcZn_hjCNWZ0^#wS+@k;p**c2vKqf!5ZWAiZ9}?+8R-@+
z6mAYal$se<WMs;ekA%MsUll5j-1*X`_2`tF!t-?a_V5Ioa((zhAQ|2v{BzSOFK_-B
zYBUQtb#&V3jp47;Mt>ZBpWgg&_|(OL&;8Hv$I%nRAHOs0kL!lRGW;d1@w7jk7;rM<
zr0}0<fBkmTWX8?mAgA5m{CU=lo#uo;|E>A+L(-q5{68uEd06xO+S;G<TU`3H2c$oH
zLi)3pk^UTUbvW5X`g3&mXOaG7-QPs|bIf^dyK|Fmz90VZ?eHvacl{YowrS4!pXuM{
zg=fOg18Co>+^=*rnf1a(<@40p;W-fA?XCz{r|@g~y`e$d@)3cz^`<)MkG6bxXwbgM
zovkfH&4W)5HO5v1GGpXAZFx-i>#XA!hGb3ACO0C1^alx~KQ?K{{eq6WOET+6yN2q|
z_(5BJqqb~r94P%k@|Jx=AC>;tq^&+s`g7^=-AcvMA0&|eAc6G9ChfQbr9axTxw)Y9
z2MMG<HfgI5l>TVTSo(tm(jO#{{vd($2MMG<HfhhmcTAHraF1lxC!5FWt)C1eY%Oq^
zJOUF-f3)Sq(jRR(vGhk<PAvUdDf66I`lBr;mi}nViKRc<GM4^m(msP%gtK}3QCaDo
zl38VVeVl&#fq{gNTAwOMFtPMUTTU$f(UucSf3#&R{Xqihk4+v}`lBsl>CfeI)Uou(
zChc3238X*TK9>F<f%FFnq(4X?{Xqih4-!a!kU;u_1kxWQkp3Wn^alx~KS&_`K?3Oy
zlbyreno56=K>C9O(jO#{{vd($2MMG<NFe<|0_hJDNPn)7voMzaAc6D;38X(rApJoC
z=?@Y}e~>`>gXC%9Dl&TFx^0?k$pR#h{vd($2MMG<NFe<|0_hJDNPm!|;fmOk{vd($
z2MMG<NFe<|0_hJDNPmz(`hx`0A0&|eAc6D;$r0f;uqXXN0_hJDNPmz(`eT#!8ajdW
zN888JpDX1V5=(!OK>C9O(jO#{{;aa&K>C9O(jO#{{vd($XSE#%(jO#{{vd($2MMG<
zV|E-!e~>`>g9OqaB#{0*&5i@<4-!a!kU;u_1k#^1b{t55kU;u_1kxWQkp8T-<3Rd@
z1kxWQkp3Wn^k<zN2htxTkp3Wn^alx~KkMx{kp3Wn^alx~KS&le*HD%ITxG|B^alx~
zKS&_`K?3Q|)9pBr{vd($2MMG<NM?r5p?cDvtL-?D{vbKGxrVCr2MMG<NFe=rh8+je
zADgt-&<UhJ+CG;4JX6Mqr9aQI38X(rApLo^?E~r0b8G_X&vR`8=?@Y}f1YRiK>AbI
z1k#^tYy#;I5=eiZZ~H*{b1jnQK2)VYFR%%uKS&_`d7<qC>CcO70_o3-Z35{J5=eip
zvwa}_d5KLR{duWPApJoC>Cek-A4q?$w+W;_FSiM#KS&_`xxw~<^yd{ef%IpCO(6Y2
z0_o3<whyE~ue1rIKd-V0q(4X?{kh5ZS<+lXKl*`(H+Rq3t8D`5&p+4%(jO#{{=CNa
zf%NBQn?U;Wk2Zny2MMG<ueE(3{dt{DApLp0O)hV)p(_1B0_o2`**=i|yul`r{@h}c
z_8K~Y^hevr(w|Z)#nK-nkp3Wn^yiJX8l*o+ApLoh?E~o#5=eiLK>G7$TMg15B#{0f
zf%NAswi={AOm+#6^j&5695;OKbgS(H=?@Y}e~>`>^Hy68(jO#{{vd($=WVtcq(4X?
z{dv3X1L+SENPmz(`tuH3ZM*%#y8Y-oyEW@pAc6D;38X*owACQ}K?3Q|yKEmwe~=s-
znvMQ!UHJMgd`FK2(w}$RYLNaQf%FFnq(ASm)h=tUp(_1B0_o3tZ68Q~kU;u_1k#`P
z*=jSxC)Yjc4-!a!kU;vg(N=@>2MMG<@3(!fZLXmz{Xqih4-!a!K47as`eT#!8ajdW
zN888JpAX6yvGfNCq(2`reVp_M5v4zfDE;}cElBAPB1(S{QTp={TaeNpM3nw~)b`r1
zdGvbHA4HV?Flw%*TMadPS2uex+k%w-AfogK5v4yLw*@KvK}6}#Cu}cDe-KgngNV|f
z+iXEfe-KgngNV|f+ik%U_6uvc)6k)NH)~iTqV(sVZ7)iH5K;Pr=<CfVrMnK@(vFpW
z(iWuj2hr0)yV2c;?rMA0h$#K}lr2c<4<br`D%*?FA4ElSk?l!;5K;Q`X<LxeA4HV?
zAfoi=Gq&IX&6Tz%{Xs<O&%fASl>Q*1^al~8KcBS)U)MZgd(t07l>Q*1^yhQ7Af-Px
zYA?Cp3Wwc(Q9nTX^LeS&{<~pHe-KgngNV`}M3nv@qVxw5r9X%${Xs<O&%fH^qVxw5
zr9X%${Xs<O4<br`5K;Prh|(WKl>XddkBibDM3nv@qVxw5r9X%${Xs<O4<br`5K;Q`
z1$$hS{vdkNe&P9Z+R!@>XfC@MB1(S{QTl_3(jP>W{ve|C2hnxmNJh^dI{gvN43jU~
z<D&Ej5v4zfDE&c1=?|ito6Bxb`h$qlA4HV?Afoi=OZK=Z{XukebJ^`le-KgngNV`}
zM3nv@qVxyR2b;@oPx^z1(w{He<D&Ej5v4yiYA?GJNq@9MAL$PwN`DYh`tuc;cOU5w
zB1(S{QTl_3(x0!|u_*mPMClJAN`DYh`tvnA7NtLkDE&c1=?@}Ge>T~%DE&c1=?@}G
ze-Kgn^L0BGr9X%${Xs<O4<br`zG26r^al~8KZw@u7oI=G(B9#Pm1m69h$#K}rX7pY
zA4HV?AfogK5v4zO+Oe7s;6`6G^e^oUb3~N>AfogK5v4zO*|C~8PNOd!nsaco8abkk
z&1LsxL#MV;iHOo4M8nPHsVDvUmK}@IA4HV?AbNar+3iVx5K;Q`Z95jFKZq#(K}6{f
zqAxYa)sy~w$Bsqm4<br`5K;PLqxP~pk@V-^WCnetKZq#(K}6{fB1(S{QTl_3(jP>W
z{ve|C=ezc}DE&c1=?@}Ge-KgngNV`}M3nv@qVxw5r9b~}kBibDM3nv@qVxw5r9X%$
z{Xs<O4<br`5K;Q`J$qb~{ve|C2N9(|h_-7!F8JusSLZdCrwxeGG(<h=4<br`5d9|n
zWbL^02N9(|-?zs_=?@}Ge-KgngXoUt+WM)Xx3=z~4TvcHK}6{fB1(S{QTp=(dt8+M
zAfogK5v4zfDE&c1=?|hGWnndX(jP>W{ve|C=ZE&VDE&c1>5q-t%kD(dAMMab`cumc
z`bd8eQTp>E+l$hl|F99IKZq#(`LXTwz2?QUC;dT0>CaDWFG_#zwh^U2h$#K}sqIDS
z&(CZ`=?|i-n`ihBhQ8Dqi?W~FUX=bIqV(q%wil&8zqAphKZq#(`IYTO>CZhjqVxw5
zr9b!DUX=bIqV(t2wil&8zp)XeKZq#(*=&1J`tw^GUC=xzJ?Rf3N`HQ5dr|s>h|-_`
zw7n?(`Mr%O{Xs<O&mU|rN`L-nBT9b|QTp>I+l$g4M3nyg+4iFJ=f7-3=?@}Gf9|ur
zDE;}1jVS#=MCs38ZLjIgqui7JAfoi=e%p)EpTF6N(jObOm)(h^KYy26eWX8#DE&c1
z=}&S(()^m<7NqnC5v4zfDE&c1>CccIi_#xNl>Q*1^al~8Kf`vcUxmMn&K}+-{Nvj2
z<_;01KZq#(K}6}#h#hNY_({ld=?@}Ge-KgngNV|fDRwMMe-KgngNV`}M3nwawPR8G
zgNV`}M3nv@qV#8)9gET*M3nv@qVxw5r9ac{SR0yW_yNNQw%(i^5v4zfDE&c1>CdPg
zYws+K)sy}pqVxyR%BI(&hrig)utr4b&kQ>jr9X%${Xs<O4<br`wz6YU`h$qlA4HV?
zAfohVYdhAQsbMu14u9w9_PLCR(jP>W{@AF!>`o;8*+yp2NBV<^(w}W@uYZ~n=6%%g
zhVZZ1!*>WXZA9r0B1(TAW_wZkgNV|fS+*CYKik=e(jP>W{>-+$DE-;qMwI>_qV#76
z+l$g4M3nwC{|qqv>P#_|{_JEUN`DYh`txwxi_)K+ZA9r0B1(UDvArn$K}6}#uC^DY
zKfBq8(jP>W{_JjhQTnrojVS#=MCs3-wil&8h$#Kp%l3L(8lDb4=}&4SN`DYh`m?v~
zMd{BzHd>s8v7R!#^>NKpuS7)Y&%U<THBGOc^al~8Kl|BUl>Y2*BT9b|QTlU$?M3O&
zBWy(J4<br`4z#@}{Xz7><{GtfctN<y3_n}=NZaeAsUdpm@L6q?9%Lg*e-Kgn^C;7+
zz3i5uTKkg>Q`+B0li5c<EDW=1_#^Ew$)lyiOT%Ah?;k$<8eKiyd?^xc;t)~#gNV|f
zgKa@de-KgngNV|fLu^4xe-KgnGspI#^al~8KZq#(nQIGD`h$qlA4HV?%(De4{Xs<O
z&wSg9(jP>W{ve|C=TKXa(jP>W{ve|CXMrt9=?@}Ge-5*~DE&c1=?@}Ge-_$;l>Q*1
z^al~8KZo0bl>Q+4WOLcQVR)yL+q;lOwil&8h$#I*MCs3BTk!1W0@{=QAfogK(LXl5
zZW{hrJHzZTw&3jW)E}4rAfoi=2-}O&A4HV?Afoi=NL!H7A4H?!XIRFiKZq#(Im#BK
z^as(>siEK-hChEw`*<B~dr|s>h|(V$wU^zAq(6_9Vfsja5WS+A+*^h(IklNwiHOo4
zM3nwyb}UMN5K;Prh|(WKl>QuJ$9m`fVe;=9PQ$iS;pGGor9X%${Xs<O&#`taN`DYh
z`h$qlA4HV?9B0R(^al~8KZq#(K}6}#@pddqe-KgngNV`}M3nxVV8^2L2N9(|h$#I*
zMCs3ob}UMN5K;Prh|(WKcQu#Yp7iG=I~Jush$#I*MClJAN`FqaV^R8p=>5%Qw<rBU
zbWn5I?MZ(SQTlU=9gET*M3nv@qVxw5r9Y?Iu_*mPbXjvn?n!?TQTl`E=~F|mZww!G
zR&#MkPqSlD`h$qlA4HV?Xw*mgbGnSxNBV<^(jP>W{ve|C2N9(|h$#I*MClKrPwyYr
z@Q1_Kgn!i-KJYlh9v7uQjKao#<I*2Ql>Q*1^al~8KZu%7-^Zmth$#I*MCs3&_P8kh
zK}6{fB1(S{QTl_3(jP>W{ve|C2N9(|XW8ST^al~8KZq#(K}6{fB1(S{QTl`Ep5_AE
zll~y0^k<1ZE=qq8QTl_3(jP>W{vi57bAkQq@P>2Sn<YdSH0NPY`h$qlA4HV?oNbSb
z(jP>W{ve|C2N9(|h$#I*^rb1`xO&nbL_cn#p7aM1r9bD`<D&G(M(us=MA9Ga&`0`%
zh|(WKl>VG6lj|e>K}6{fB1(S{QTlV99gET*M3nv@qVxw5r9Y3eV^R8ph|(WKl>Q*1
z^yl$*EJ}Y6y)(2M-ECyk<D2JCfr!!{M3nwK!Hz}g4<br`5K;Prh|-_)?O2rlAfogK
z5v4zfDE+y>jz#GYB1(S{QTl_3(w__MSd{)CYJS*!T>68E(jP>W{yfo+Md=SBN`DYh
z`h$qlpC{R|?rSdAJ?Rf3N`DYh`h$qlpC{X~#=>7l7mmE+g671|5K;Prh|(WKl>R)$
zjz#GYB1(S{HD~$gkt3(IHlE5x?Y5m0Nq@9MAL$RGB>Wne{w$SwPg?q;9VRXP(GHWA
z{%D6uOMfnsW0<t`M>|Yf`g5_2Flp(Jc9^vE=MouV($XL8Flp(Jc9^vEM>{kMhjx?O
ziKIWv<QUp*;ny{{9zE%gMy(El(jSd_I*5s+KiXl^(jV>6NBXl|rrbyRqtT?LKiXl^
z(jV>6NBW~tAL-8unewEiKiXl^(w|FZgg(+AjrvG`R@z>a{%F)k`twxNtG&#fu~fdS
z8g9R=nwrdB81}gsy>{f15QKNQmrI99OMkS(q@_RFVbao{D`ZNOmi}BR9VRXP(GHWA
z{%D6uOMkS(4Y}-7K9TfCJAA6?(CnB#?IQmz<6DQq1NX|2-9r#QxLzd(y;(<?Ncy84
zCN2G0Eh9`?`lB5tE&XY3BEqlfeWX7c^^yK)G->INc9^vEM?3V9{ya^l++KMp{n4ns
zUT?jBc(C3!@`cvylWWxWI=s1*_oP1>wY@0)(Wvc3>CYOOM(-*=k@QD9Oj`P*9UAk9
zlm2MbNBW~t+l$hlwKC;C(jSeQUhRA0!O|aX+DH1M(Z|F3I_b|k8M}}4N29ja1<gZK
zjXZBz^AyW9>LdNpsOi<t_<f;EdxedpKic$`(85W7G<wC<5Ph@RyYY^ZzqDg-)~M}8
z>CbvOn6?+CKN_{YDE-l>>D69fE?tgShA@LihaWW={l>_1LNH_GRPAtf`0MNwo9NDw
zo7-rKMt!6|8ugL>Xw*mgbJYpmg`ki0N2B)nLFtc1eWX7c^^yK))JOWGQ6K5g(`ANz
zq(2%pS7Imq(WsB~N2B(*DE-l>c{)re{TbSBX#bhpZ#^<|x0%}w&7M9h?87&_Q!+C1
zF<T$8^(os2-OPT;)>|JP^5CD5KZbvmHT7YEh8LOUKTWIY2PDmZMz<dtnYs1WP2ZvL
z*BRUP3M~q)x01h3J!SjmuUqRd;e;9*I%WH&$F_TiI&(re^N^v(?$XWT5xX=K%Xa>U
zV|QtqJZx%E;B>Pa-Z?lT7WBqw{<>ZGt4U`|8is7r?Z+EGc9$c==0Q7H(6mS%S`T^X
zAG^y#>oLjmWBe(i&zA5MnWCq6^Te1sembABJx=FoJYlDA9Zta6)5BA#c}j$*kUk+E
zIx+Q{Bq!z%XM`(N@Q8({?9g9kZX13d3V%+Tzt35}cFmlXt1h`>{j%jr`<E+LUOea0
zOD>sn^`eDK7cMw>&GKcJU9|4tD^{*rfAyRNhb%heFgBOIb1q)FZf$bNA#)Bnr29Sm
zq51#w&N}P#bCcxaRZG^azGUg8%U3Nu_N4hsFS_dL`G<r{Zj!8Bw=5XX4!NwEO!)J%
z<txIUgNbY1Gsc#$4SyWznyl_xgt@JhKdxGH`teJSTekd?)ytNzSsMB^t-~!s$CqBQ
zz9}01zHa4}%a>lc{GukF+Kf13_~7YT^M_<)#?a`EqgMqL+wimv;rF2p(?&lqeDL<8
z>zlt!TQ}{eqqmHf!w2p3s%x)(<14Sdwru`4GGq9_p)*4e{%>Tf(Kn2iqx0T4`iIef
z9)8sJ!;jjrDRz7F+vvBO--V1`JB~(gY5!a{zmKdReM9)~(6m#hjqLP>(Kp#rJ2Vac
zd!=^Ra;3I+rTzy8xZ{>9<qz<GFsm(CY74H_7AzGGa7&${VODRnr|5%Y*&m$e)q`_Z
z56-iF3(hKBMc=Z8PSJ<X_U`3uGA~~L=g;=pTkgec3tro2y<zm0+lGh34c&w67H{7F
z@-5z_N60PS)|0r!d*eg5cw6X_`G5X0umzvHTd>qaw|J9(rP_k`8V{ZA|0~P>&@JBo
z%Ci5TKiePdw|Lc7&8K)%{?|XnTk>G}9Pf>*|3BR1y=nNMhu;`JzmxyHsr?-9^zeB`
z`$=B-EN|QJS>9VmZ*M=w3!mh5|G(qtOQlKI@Qv-?-Wc9v;<LKulfTgygi>#8KD2vf
z^IP}%-)Q?W-{^N5GV+Y^5Bs)W5gM0GhqhojdTUg0hyQNDrtB@@P`2m{Z`qPF?A9`#
z;eY#(yMkMA4d2wR;TA0T=C)vb+WfZ<d5h0b*AO3{gcJL}J;Scx7CdB~p+B+zhckRI
zpNHKcKlo?31)nMZKRIniW`x&^hn_3{)62saKXD#<uKdrh*<1WU3D4>7W6I}-uU&_e
zh2i%H{w6xP@}iZi;%|tXZ*TYfwA}S=HFWLp2Zr0PNnh38adls^zHt1{BUg_;Km4uz
zdUe|s7qlOgKIrbE|F=IX{nlq>Jty-~Y4mOQw&C0Ghwh?>CwZU$&|P%<#_GR)!}ic!
zboXN>55i0Qga38+!9T+-{<{01fAjUwU37RVKlE&FZ`s-(nET&*A$`z4SDH@>ySwPM
z>n>We?wDoE)*RdZSmm+nSA?IcoVWCxMT?gncjiflCYP*SbIG}vtz5CL#TU*yeBlG}
z1q0e2Hh?c2zz-k57Y*QxBfelkGtYT*lcnodtzWx**?hE^zx2Yx+5-s<!jE?@UA6wo
z<5r!r>bO-Wty#T(Y;F64rRU5)G+DZ0<rT|Ut@eEnoiD}R>huQf&lfj8ySjR<UFrEt
z&zW~vx1xiy1rN~gum{K%K0wBm4C^s({@nPH9p`*x$2lL_an46}oO9fHOD~+ipwGDD
zoa2sjjyujd?l_OmC>eLqd=@85*Iu@I&AN-%ufU@pD$ZNfEL2o*-s1MGh@UbYj}AoI
zM+YK2IuPN5#*Gd{+7CGC4sDKMz=_pn15T_q8*pN^*`j2{s*A2%o?LOon)%^>&ChCw
zi%N5a(F;rX;q3m`ocU5<efTl%c?*}W!@`GCsC}Yv9Rr=esC_&Jajr{fe`t52FA7iY
zD=xZpZSx%I^Yi5H89c8&NxAmpwfLBi^Jq>oHXrlx_I%6(Z!cmI)vM3arK?x0aLd%3
z@!f)OQVs7edC|2}+DDU`-;T~QVNM;64z0rjio}P|)?O4}pu$VfJUI=b3u4H+Q{?cz
z{q*!1+%GzGx#)#g0snY+C&|2U8MtEgC6^-(Yp}3A9pY~C_{Kpvo%_C=wwP<#Twz+w
zwd`T8We@Y*>|vh%JshpXg7!%iPyBE_+57?xSOIAt)$g7_VLhWdea^CGnsZwoFHOhe
zwdr`gI315yr{nSRbUdDCcNKRF)I1&fT=jc6ntpp~yCTie$~}NzoIY2)Uh8-X+Sc(3
zv^ZXX7RSfm;^^?Zc@u}D>~oW-^sxSy`EbM2Jx>=*kT0Ad=gh;XhaT4dkr2*@V!S<<
zahyl%C|3ktD#qJ$KH*X7T|w-F8rt`}-|69KmR;*;lHH{|x;A$>D$?NrMR=fLCSB|3
zc)H6nTQ`T<&Cs3Gq0FKIR|vUz=DB1F#X-MIP#ECw=922h4RyNuT$&!{()2KwCgARJ
z7!~PoRHVZLiY!c)o^saGr>|MLZu!#XtCsl-VAnTV?G8t4ap<5$?ReC_?_GU3KH<@k
z2#*d$c=YHCkFPFzlVwl-@o}Sh_Ic`t)-8?Z*wSc*Esf^a(r9)qjh4KnoLM-_TFMha
zDQBjXGgHc$DUIgPy%5AFb?-?g?^cfu?^cf;f4AD+HQ~$(BXlpt(bPN4xrepx_xc}-
z^t+erVHWA(Xa%|=(GqkxT7zyTd?1=rXV6WT2J8`L(_OK`Vh&ui@D|^lpbPuoj&zvE
z8|Ktu9&ZoxczZZH8@nRWGITgTsCn%f$>Pnyc04N6U542_%%#K8Tsl0UNHiCDM-iW{
zgB~j3i<4(AU$c7cVPVS4$5t+CAD`ZvLh~Wayn#vdagN+ChN&#Q<g)OEZ!*?=(9(RQ
zBkw@lcc0A*#$tOqn8DhQV*KgQtw(g0bT~R4Ivkx2i~HaFcQ`82;Q>XW$FXZ2J&qlY
z9>)&zaSSIz-&?0~z93n@YVFEPS1n(bhP7Se*GPItQxhJ|O?Wgp;hbGKv)k2c9@y|Q
z+PoPH?|4^SvHGHQm`7;Wz3_*#soy6L&7*th;OMaaQQzxocP-}OhT%Kh=Pj+d<&EB&
z_OkvTspwl;dy#6M>wWI@8{EA|8N34Sa@VWGhoZrK&e$I28Qa4=V|$qE)SOg<Zj9&a
z13mC^y(l_2`n{iOhHe*#Pum`j=ij#G{F{j`>i=3GoMpz_52_O{L{~q4esr7<%6NUQ
zLE!V|_5W<4#nCLg*3l$89L=%A(G)uz&9K9qU|9A;^?~ho`VYF}={_*vL)aW_d!rj4
zRg0se>Q1SsNQa{$9Uf35TAHr);pXmsY+ZD1>>6=J!cla0_kBJMX&<w2t&3JFT#34`
zWCnJM29fJ2kEeM!`rp!aI9inUIpAL5Ly_(XxUxOWB0U_<q$|Re?X`~1u5Kng%+R{K
zoJ2+R4TxM!PFQy7^0iBrhp)N1kD<ehfxD>6$Dr|{cAxh<-aha8EaW)nB8+pcLc`~`
zcf6d?IFIXe?FZH2N{rWupTu3AXq{y~z567;bm3K`ce8e^xxH#{pt?)Z1LxtRpOw#C
z?moB<kEFf@X+Hm76vy3DpNAKE$?bp4+e-qEZoGNK<=GNH%>B=cu&x?JXJmKh&c`#1
z++jYPJ<Lb5hohq!^k$(wSPmJc*xhe)$R6g9J<K6{I68g0+FZw8>+rdGxLaF$(N)Wr
zUVPEo<#?`zM&12ISnKwEK=U@DeIH<-k>jm;C!&4Ri;7{n=Fjc(BpT;jf^p6@80TDs
zaULCR`w3`#(sY<-Msq~nH^kB7B%HGxZ_indbIx*{M~{`%k7h4Co~L};9R=N6_Hew-
zWz{^(yYJ0Uze2v`b63|eGwB%4i=|^1xo_h`+`Ue^*S4_i{oa4|Fqf-`xmrEU#p+@A
z?o&Th=^cu@XAX1i-Okw4HPn;O!s3%bI&d*V2fY)HK2n}P=&QFu-@Og`@~z|1kxTvX
z73iwvSFgiUsd+5A4}jfqH1qBMuAsxwgVA9=7^Zr>8g2DH?}OSmVSPU9?ae4Yt-EVe
z{4^VIJ(QP_Xs&%<TEa01kDq1(u8Gn<I%Ijn7FN37{hoY$)w}%p*WvJPsPD6|?+s2f
z>-KF<c#icOtb3>F9`n#i-|Rj>A0Ae(PqaGv2H8GsdaV}^zNgUlc;<35{+UkuzP>p*
z27jN_t>fVDqx6f72d?kmRfjvD)y)qIbsrHtzyskfAkBrM&l|QLj-E$dYo43E*3nbD
z-#fF=y6;cfjPqzvX&;R$*9JbbnmXMzBd*i&L3N_(OP%hb9DXXxzT}6+ZXa#?`JG;_
zCG#KSm<OrP!_eoRsae<-M@Q1(_(1w!6T8>5s7Qwg6p0t3tsP(8x=(rsJy+d}X!FFE
z4t%19L+!pXb%mNGkdK(<y;J-k#EaQ|s}LPohk0aSM%`U(Jg~mmT)KAP&t37<YmTnH
z@#9kWFelW*(S*7p@lv<7&CRU;0<T#td6Z<g$Z(--ew?T|SHl*S%hz1AZuOd_$2|W0
z`TZ}}z55LJ*;bgUe9q)n$pm~nL(skFjaI0`(F%1qTA_Zg^39;_VMav;yvlbtTILQ%
zuM8cIR=>kM%CO*atMAsO3A&ri==l3SU&h;W1;%+a`}SmrCg0L%?sDR|*Sfw>#NGoJ
ze&iv%FK)Igjc&=>Yf?0{e#YTO=`hzV4AQ;)^JcS$!|QMJ<Bn<Xlm74?9J2`P(mk2u
zb?+{Xj%(%U(P*a;ok#sYf^BK^IJ7icjFv`^Lrb|7;YeB<&8+)T9(VoJ*3ntg*5KT<
zEoTvEzx&Z1=34Y{G+<XG8d2{#qdT<Ttx^2Q^!q3!JYe#9cl&dN;S$XgKy%JZY4mWk
zwYU)4HhMU^6V^>LEQHL*p598MMQht~ZlP`W3K!u%lM9XIgRd};=EI9M%P(3Me|Qm^
z4S37n@5hhA5qFr=?O{%=hxr)yaI~6TZ7yeM-F=c94&$UVAD14NwmU7S^XJYxZ0^GO
zho%Rf6TZhg`J#0lKlsqak4z7~ve`vB{Ab<zRm+cRU$$0W($F=RTy|90y!qgT3(|ux
zO%D#cDj#*p;s<=&5njfc#S1Ur{eIY`y_JuicP))psHM>YwKQ6vmPV&wOQS_=Dc3AK
zs4eBplyYWDIWwi4nbHS%@6hLEzk5{UXG8C2f0kYuHmb(Oxp~l~+kiJx<8Pw72dMjb
zr0BD`Fk^XB8m)!!Xf=dK>mi&g5+>UBEyOry{c+Cv<9ty4=xpe{wOG0AYI)m$HEa&O
zy)MKnKj=HE?(6ipefLf`@V;*;!$TqOws{tYW9s|RkMr)K3s1|-m#^txJ6!YozLRgx
z#P+71%h<!wD#~Y5JPX21gh!8(aF!o$Kd656C`q08S=;ZXCQQHk4rAh_o|`n^Dugvy
z*Y77o+ND{bZ!GaaOZS%3z66D%k~_`8J)(7x9??1okJdqWv<|`-C*h67^0na$M|qFt
z=N!L7>+Wtiv1S3~y`DY79*&2XH#@6WE$5H##Q%b-`(VVC?cQhctO}#`dk@#c(UiN^
z3&X|^SD$|RIlZ4EvO|T(sCzPVs2+~a->x->>a~s@wXSvapmjJ}v<{EIFh*D1Fi`hF
zcQ}s+{@hY@<1Srz5ouOUp6GIBxPREzUVWkqU)zNfZ%%^#pOAEzOW122FJYgT)@Ef}
z%pyH}*!Ufof5+Wx6R&<-kq6Oh%~c9`z$X(Oj%s%}s@>u4kv;L0prm)_pnR>thpt&F
z{aCf{=Z4*90^^@`nO70}JxkMos~sx0?@HV&QnLu{0~|jYS{y$Jat8UMY2VaFMY>CH
zRAj)n)E$nVQ5}xfy~EMEcQ|@X+n4WXA}t;8&k1_BMFYOm?&SkMUhd@sK3?wS6ODg(
z|JU<g|3wqzT#Ilb^zKa__!Ns@C;I-_Qz+Q?$DYP{bS6rBKGNguqsO$ny^YSU4o44a
zhdF3C&pXU9dpJ6~y4C|`5>|B8Su0koUB2#=?gy>?lUu%@;gh?0uC>>p@G(OBRp-3!
zKjGgJH(z`%=>Efbhehdb{CMy^936c7BJ7^zz1BSV9*&N(|Ho)y{$2Ixgp!|GiVj!n
zgyZe*OxGq$!;2VJE6k$%Vj`Zjd<E@-Fpc(Yb~Njja&DpRfUng%94%jm`55$yaQS*T
zI(NDv(fm3*_$~4ST-AHuVJus{{^Bd5H+bDCa=80JRsDuT>f%RVZ5AD^d<PuXz3&C0
zn@oIlkna+rGgUa(x_#LDyp}Y)yM)JeIv&^QI1gjI4j;8~9z8zepYhlix28k)Ia+)k
zYLDLcu<;F5^G)oam2Z}CZ2i&|YnDH4=}9L)6Hkk9c6Il%eMW6xYva!%yJg_vhBESn
zO7z4S@QHYb59@ccIp9X2y%StCu*2X|(Nw$79v2TR#fPkYWcqyhAC9?O3b%BjeZPCP
zrcB?j0mkbL_~4|y%W5Xj_Ymcq+(9?(3;G>p+h=gKg#-H>J}~L~z_jD=jA)jjyF$fJ
zypG3DypG3DypBf?Z}%|+@%XTOaKqwv&7-SphX=F{&$iX8E=}9t9_afD`I)2UpM<Pm
zv-FbHSFFEsRnok3Z9WQ$e&DQ`q<ojty|L`I>i5Zd?^Bk(S5G|4L*f2k<%MAUDr|1@
z$A7w^cl#Hg<?>}k_gVGD7hQ7s`myfQ>b?^SZz=qox_700&V%l!Dg5QJy^HR17BsE9
zf8yAFVD5hgx_#)IHhunKMDOVO>_gGZ`s_o|%O2>5g`!hRp8pTjhfkJpc1oWCH|M=e
z1JCyHegkgWd;OyGTgKx&!V<RUW&G6a^Uk_i?*ZR736INk?c>L`-(EjW{f@_VIzFfl
z7iqi>7h#--Q@-zWqPKdX!P3=NENeEw2si2e^zMH2%{_0Lho<`n{w`>S?eogl!#vnf
zrfnP->0XnfCsl`8B-HLO7tBmCIt{w^T(I6;qSoC7I?S=}GKMG7pnp)%EgcV{8K(c+
z>kdZ;(P2L5y&}<*vuhn6Svw?;tXZIT^`qJyj%s&!QL=h$EPN+*QMk2^{t<T9#J;Zh
zufM~ny&sG0Hjd#xK^)Hq-`VszU3%XXxXW$#&Xf;9IAJ;*oktz!L(pr@W$NK*t>tO$
zCfTfZ_q-1GqRmT-{7{zphm-B)*gyUH{)A5`*1mt^aVh0tDdkZq<v}Tp9{TP@G8(SK
z(Rdw>2JCP&VuuF|8Le*DnrCu&EZXJZL;~&i*{C+=JbH~eYi-PF^coMSG2rDYJiguC
z&fw3;x}0kfM(eIX6LpIgrRx^0N{6EZ?QnER9p(ar^Q8Yrn0;PfwJpa}%Haa-`|l6N
zIS*!>N7bdyp!!_m@jB6QN}XtJ`yapFhW2mHNruO@Ey5`(jV97v;i9KthofcbFb51r
z*<E_0A{~y3ba+4!PP<n-TG*~gbT}R6I)x(Lhhr=fmP9`1kE(R{-hD2$?dzR;*B{Ea
zTb)FQ-_q#lTN)jFOQU0NDQB&tMRRW3`VTtB_jQXuDr!4$(qTzj%1JBbq?K~gO8ZYQ
zUeR_qx1ga$_ktfcZ$JCwoWp{&lyg?fIV<Iyl|~EQ){Ty&r98vJjQh+?DQBjXGgHc$
zDUIgP-H*lVBV2!4(BCD6dfoR9T*4lXX4<umrrP0Xt{vuNLv6XGkH+k~huC=gXjEw*
z4J$nSbD68wHMfuYj$_VctFK%>XYDiQh&q0b{0Q*6)vK>qJ7@f-f5Ybo;YWgThZIf;
z{otFAbO_{P%)=SyT*GnB!x`s1oN*qVjWRBmcf5Tx&+c=!Xqp|4X4&EJ1NwuuTOIUo
z#(F<w;XZe5-v|0d?LP8}4!Oh85qCH`;0{N}+ns&kTGD&mSC57F6D!w*XTkC{D=xZZ
z`C*sN5j1bkl9Ml(bKF_SpK|6&dRk2GEa^^`=4Z#lNANwNga6_3dH#pXyKb>h4IM+=
z=jYPJkJ0=miJMO}Qg4bu#4+&KNHUZx8qT78Bp5u->&r)yb$$7i<mSG7YVxtZd|FbC
zWQqSZl1xtyoYIevCRtxTBgy;nt&*$z@~xB0ruM79O|qdc-!{pn^=m&fxpRkO{PdHN
z<Y7s&V?RDC$zF6qpZ41&H}~bUlUX+`@6&$!Waqwoha~OGcT5iK%Xdot{EB|{AD$!|
z`thBU%lh(NlA<r)HJW<^Mv~nI@ZAUSJqGYS2k^Zj9%PEil;pR6_rW#+3?=cp?GpHK
zvTZWv9`|PE4KE!(M0oA^@ooL_^=anO{5m)MZzzc$$7crK)K8{o;ZNhgUKIW~l*H%5
zt%3JDuG`x74@)vR5BHN&cL^U8zO(S(2)|DF4B=ac2@i$y`9{YdA^f$DA1D0HjxQCy
zQMjHN&k(-J@mC4o?D%_xZ?)4g?F^^MJij1(mg9E|-^uZz;qJJ0cYF`w`v{*Y^$!<5
z*YUH3AMN<%!j}lwGxf#7#~gpN@C}ZCO87>{|6TYd$NwaJv*X*3bjO=Myj!=c<+$bv
zFNLSV&k|k<-$D45!fWA23co??@7&d&CH#HD=L!#M)ArXU;hFF!3IDb5Quu+wx0%w-
zf0J-MZx0fl?9z?fJP(^+rwN}cT<3p<@Z*Iy&;RDv%Z2B{)0QU5YlRn%zg>9g_(z3T
z!ZWG!S>eg9-8_|lLwM%+kAxS(^*sNR@E1A0?bL34u6KN2;jeUjvGAK6KTG%<9A6>)
zEsj4&_&XiHN%%&`-zoefj#t8Ocl_JJKjZkXh2P=$)UZ&^_3EpR?=JjK#}5_$UB^!q
zUOS!(|Ec3o7k-c9Hwgco<F^X`v*Wi5|C{6A6h39Q?)(XVZGZhz_*RY&P4CuWmg74M
z-^uYg!gqK4MB)25{$$|?I=)W$A&$RH_yWh@Ec`K!-zGeB{2Rhgbo>{>Pj@^S?bhKO
z$9EQfzT<O+KgIErg)ehF7yeYouNFS$_$!28<@j5LKilz73V*)i-x7YE<G&VugX7b}
z3wrasxXJN7g}>JEg~Ch6&lLVv$5#k{x8u(hUI{-?&fA-WC%bp&v+{Qe&m6CW7mj~R
z>pOmr*58BmN5TtGvksZ#y9zHHpC`O>{3PMYo~-|5t?&3ct?&5Dw7%nS()xR`{>Qbx
z<D0a;<3H2-j^D5KQ`X;MYgr%1A0@nS{8-_Y;}-}|_GbMtt?&4YwZ7wT(E5&lSnKb@
z`d`-ij{jKeJAR+mcYM2WW6+!@$-b<ApzzG`OnBk=`NAv5S8M(KSpP*@-|>Ia`i_5C
z>pT7xt-n9(->vl>zhCP+zGHYR(yT+}_@jj<2eAHe!ZXL8D7<idt=4z^Wm^9ctp8@M
z@Az$6-|=s1eaC;L^$%qIk#NJ`ULPFaO?V;vLvkIPr|lov)lq(u@Z=!!Ckw9}U#s;W
z#r7}J`i~|rwf@26AJzJfe^u)r!uCJW`g6$d)B1DCw+l~+_Iz;sK;gwawtuYfY(Dwp
zg(ruSU#aySe}UFt!1k}z`iGIfU+XU<zeDRg{zI*QINSeG>n|eTHoU=UuMdmK_Y+<@
zeuVJiF>HU1@azckm0JHu@<Qu7{u-@+6x+X7>mN=2Ij#R#^6zVX$N!-9Gq&GmJ9)kw
zL%y%@<XG~@2(KJJM|g1@+doz7A5Z>#t$zafYqh@PAJF<Ivi%pd{z>Gu)<2p2&syK{
zS+l!!C{AJf1BGX&l4rt`)5y;kUO7Id^-pK}>$LtE<fYa>ll)^^UwAIpv9AhG&+6JM
z|B3Lz@%x0=j?da&&W9zebAa&D@uP$%XS4lz!gI$j7hXAjjqvmw)_INa!twVCuO0uK
z@a$aH`JV97@&6Q_oX7TCg%2E>>qGAN-oh)#4;P+3j&;ryUO2v7c<uPJg=ddvomUAj
z9e=0r<Oyv5Y2mr!-w|Fp{u|-x`K&W-M|oa2zK8JI@dd)O3s~ng;icmj3r{X&`)3Nz
z9e<_p%JFvyPoKy-mGHvxZws#-|BdkMNvtz{r*0ie$M+JRJelne7oIzQmhj5)6~fb}
zu+DRY7mmMLc<uOmgl9`x=X1hK$G<N;$=Uu7!gI&B4PPy^_YaQmFFd`7b&e8VIQ}@{
zweS<=I(E76?BcGD@@s^bj=x5DatYhNM|ke|zX-1!|E}<K8SDI3c;WbH_yDt6huZNy
zg=foIXMyn2@zaDSE7<;G;ko0_5MDXHL3ny8>%2{P;rJ(o*N)#QJiCl_ekHtgd^mj3
z(%wg{Wcyu&=Z?=6UO9e}@bsyy^AzEQ<Liajj$bc4yPS32EWC956T*`#*#7InbH{%!
zymI{S!qY2R=i%Xtl4gAh$L9#I9Y0Zcwu*J0EWC7lo$zEe+g~p{cl<5FE5~mao{q83
zox%&p?-5=*J`%oQYmPU28td#TymWlN@MI0!pDH|e{9@si<IfbHu4SE93NIXgr|{bG
z&j`=fvCememyZ8Vc(T50pUQP?G<+4>tV8Pfp29Q77YNTCKUH|)crLtj{OQ6g$8Qi`
zJASM1<SNepHsPt`Ul*P^{&V5E<9`=kIKET(O1N2{((!|ZSB@VqymtJF!jq?S{!bI0
zI)0t-%<)@<=Z=3wc;Wb0gqM#0M0n-+Uxe3=&kkQKHtUdF&G|o4c<Oj2JahaB!gI%0
z2`?Ofq43i2*9)&4|B&$7@h=Ncp27M5Sa|CAeZn)xw+mnSH|vl){z&14<Hrau9lt<$
z<@nQt*N(qLc=AlnzZ9N2{!!tX<6je=JN`4_h2wu0UON8pZ~<x7p>lkV@Y?Z{geTA9
z{Fe$(9e=v;%<)$U&xP-obiZyDUOIl8@Y?aO3s0Zj%}49}OnC12{aWAg9ro_lp?3UH
z!qexl{;|Sy$IlmDI=)JH?f46Yr_VhmX@2SaUoSj&{DZ<v$G<4NcKk=e)8`$7`hOOl
zJ3e!tZXHU;_ZMC}ex&fUVEuE2=Z-&B>pOmp)_447t$z*czfbEs{&}tM`1iHG<G<JX
z&u9Iu_m%5|<NF9N9bYWGcKmGN>9wrCQtLZjXnn_DqxBtsuhxG7>wjMBJN^T$@Ax0J
zzT-2)3E5m9(igJ+0m5^~j}l%wexC5!@hi0ci&*~!THo>4YkkK*r1c&Dvethw>;FXS
zJN{R#@AwY;%k{zWM+={IT~|MRtkM2DPWW8MFBHDS@uvwNbNo8t8yvqy_(sP+DtwdU
zUlYFB@t+Bw^%BniZ^Gv~zT*MiIxKPgVBuqqpCEjL<4+d8(ed@dH#z=t;hP=5Rrsuz
za{jjqpX>OY!k0LHkMJ?ar#zxN-VKiLE_|co3xscS{B+@)9bYDV*2_5mXA7U}_)Wr>
zIR0+oV~&4T_y)(nCw!yhzZbsA@omEw?#*>zv*QN{pLIRwf3)zqjz3=b6315wA9MW0
z!Z$cx3g77X$Axcl{2RhIJN_%-vtG{mk36zF-nowNCVYwG3xtn3eunT3j;|2D(edXA
z-{kns!Z$nqe&Mrj;QYTRe6Hg^7QV#szX~se-z?X$?GNhKA$>(xU-?18E60x!o^N3L
z^MxljlCKtCI{sqe*(=%p7U8wy9~EA_itWEDJiUqhZsC>V_Y2Qo&GtJ!s#}NTAIJ|D
zUOIk)@a#2g|778{<LiYNH?#fq!qa~we~a+S@!N&xuVwo?g(t5gzejlK_>@O?$D6&L
z?ROVmJH9}8@lR}jy72T3<jaItjz3#?ehb^*Bs?j}-z~g!{IkNdH?sZrh1ZV%QF!qt
zwx4;hod0hoKR|fp_|d}ix3K*ageSL>j|ndwe~Iwyt!)1$;kDzp2`}Ep_TLnqzMcG6
z!Yjw89MT<c{tmX^LwNE|@`b`n$IlX;y^HNH6J9%hjqu{#Z2wx}>3hgOD7<p~%fj>b
zcJ0IMT>I-kgqM#0S$OUE%sKM7zmIkH6P`Q%7~!SkON7^suh9A%S^wEu-|<&zeaGLa
z^&S7T)_*_ie@E*({u{0D__Vp*I@FHuAw2y6>n{+VJARt*((#M6zT?l(`X6Nd4O-vv
zw`qOHKdJQ{zf0?Xi1qK$`i_sx>(-%kd{^PM<MV{4A7=fNh3Aeh)%uQKrS%<uxz_&(
z>%T?oJARwicl;Y#-|=5){g1N#(0sW*IKGSU((!r1YsXI!o_>t=FVgysKSS#~exufR
z{2f~V<E;N_t?&51X?@3ktMwh9aj0A$KEe8X3(p;2EWC95Y~i)zE4BV@UHww7W6u*_
zIsR(l`R#1~F5$^PlYd%x>G-#WXP;#Idxh7Ik1Xicq4*Tr?;<>{$ma^L91q5?_Wecv
zX|{ig@Z>Y(>xGw&UoSlS7q)-1@Y?ZD2roX%_FosCevbU-!YjxBE<FD{+wXK(cU;N8
zk{>L*bo_YX*&S^EMB%mLYlIhHVEdN{PrpcB3a=dhsPOztZ2wi^$(PCR7G663SK--L
z*nazk-8$5cA0)i^D%&3;JpCH^`NAv5R}0TKvHgpLCtoLjgYeSvj|k7c!S-JjUOWC%
z;l(%E{%^w5JIQxCyjzFL@k4~?cd`A6!jo^2KSg-y_*KHQZ?pXk!fVIhD!lj(+kaAc
z`fudl5?(p}YvK8K*?!t0IsgB?;}^<xY<J<g<MV}Aj-M<%{T}N)MR?)(I^nhBFBP7B
zpLI&%rQ;tFp8SCAzal(${3pUI$NwTc{UPhjUfiuu;rJtk*N$hxvzm3DAiQ*ZmGI<8
zZ2v;xx#O=FUOE0j;pu;{&KHFjj{it_?f9RCXFq10hdriShtlx_geN~?`=f;Cj-MyI
za{O}P>D{dJeBp)T|0uk6e53H}r>yg@!b``0AUydQ+y6m$?)WxG$o0YTeTAn#XPqO2
z7mlARymtI@;n^=(=UU;V<F6B*{F3cIC_H!kOTsJ1e=I!x73=&(c;Wc=M|SH_JN_u)
z**&atobb}|CkjvQW&5?lbH`sMymI`_!qZ=Ob@YAZ$F+{*UlU$Bez)-2@xN&O-?096
zM|JCvJN^jarQ=5luN^;Ec)FSOpQ`m8zeejjezVqh{C!&gx2*qpt?&5vwZ7xO*ZPic
zeRQ`D>F-#7AK|&<i-nhtFA-ileyP^~Pu72~)_45XTHo<^YkkN6MeF~b^}nn29sjM?
zcYO4*^1N_-FX8DQSbw4L-0?GnmyR#f`i?(K>;IAUU#aySe}~q0ywduPe@E;8iS;*Y
zeaA<$ZXHU;Q{lDai-f0tX8k3?bH^{!`i>V`-|?HZ{(rIlMy>Do9a`V<TI)OhXRUu9
z>(2^*ZGVo%@dJgIj%UJa;c3$Sdc5%DFX0d2SK9ubv_GcUe*f$E^QC>}_|3v|$KNZw
zaJ+fj)zmK?|E}=L@#eDAw67hXer(5+zlH|kSK9ubBzp=^9Y0KX=J@HtbH^_cUO4_t
z;icm@3a=c0yYSlaPYF-%=ls7VJaznD;hE!8j+67j@!f<Mj?WifI(~}q%JE!y?fBD$
zCx7GoZxEh3eyi}z@!N&xj(<~l;rK6wmyQn|->pOC_|C#>$L9!7{?7TIC_Hui$-*<o
z*9*@bf4T6&@mqzLj{mdp%JI8|*N)#SJW0Zd5q_oZ?@2QCgl-*D$M+DPIewV%-0?Gn
z7mhC%UON69;g#dB7G6949^uIl=l?n3spH=lo(T_M<F>zkFT8Mk>l5XCaC{%($#6HW
z)>$k(b9{;L!tqPBzT?l;`Xj9WYOU}1d$hjepVRt|e_!iQVf{a7eaE*wsauD_@%@EY
zjvpmFnacW)6P`JKrPg=+g<9Y7f71HXSpUOX-|??#eaG+C`i|eP^_v%n@Jk=x9Z&Ao
zA#?m-;f3QT2(KJ}vhZY-_19~C$6v1X9lurUJO0mFe+KK{rS%=ZSL-`I^%Ob(9p6KE
zvK8wu6rMSLmhi&y%e21Z*J%B%S^u?K-|-J>eaFA7^&P)k>u<yQf7AMoKm1fV{~ezz
zymI^$;mNkFf3fh)@n>m$$8Xa5j=x9v&xLQ(o~23h72&^k{9fV7%x*r~e%sT!<4T1u
zkvazp9}~WV@Kc1B!Y>=@f|XilR#*Q*Y5zjuh44!Ft-`bIy7uAgv-a1gwY~7`h5tzF
z&+gjqEBt=px$yIZ?{T`Ex59T6zF2rIJQIF_@O1mG{w(3^g=fOG{i}r+uKoLkm%_u-
zs{QqK;hTle7Jjerbcb$SZNKdq-TcRdYx_qEFNGf{bxsw2hw!b0Un;zI?XMF)x??x4
zw!c+)DtxXyzMmJK@6@#q({6wLSa>B|+fO;On}4!1+wUzr7q0D(6<+Sb_Di+St{vC)
zd7khk!gYOKC%h1z$^35<UhUS^(ewP<!qeS5UdVC%Nq8wd6~6sha$X77^W;$Bn}ko1
z_GbyNg?~u+YT@M`-M9w}f0?!ye!cK_2``#ACgGQ!|Nkny60Ym>GvTxL>e}o2jD!Pk
z-UnsEwf(-rH@NnX6<!ISEAv?@e6#Rvgg;Aol6K=}!e1vm6Fy7$M}_CE{kMgeuKj-s
zuUz}>&zAFT?`~YJKSy{fJalh=EfGE@T(56e3NKyz8-#Cm?cb&K_vyyf`d`-i!nOV{
zw7&2KGM_2ubn~x;?<zbMp6uJz*Y-yU&xC9HCkW47`!&K#*Zv0KmGIqV+;<57p75E%
zKPP;%YhMfBX1{Kp+WxP?Q{h_w;pcY8d!%cBsPI#TkI1-Z2wx&x*Yi^0g>Ze{xkh*`
ze6G}ao$z%3Zl3x)`moj)uIJC!gy+I%OPyZ`Un5+vpHt53j;j!^*U7zvZ*p}O3r`N<
z`E#!DT)18zt`xpOxX$Or!Z!-n`M*(kC42{&|LuW4(0-oP!QFiJllFIo|2Ef+&BAvU
z{u|+=hji^{2;VwfcboRxIsORYyE=ZH@O>R$DtxYRJ<p#Ze2L?)5<cemdxXDK_%xa4
z7ldzc{BGg@;P}vRcU-S`d=KGo60Ya};lejMezx#WI)1tEO~Ut-dA?ZqX2;(weAb*}
z+m_m1_w$_VxbEk<#PL5#oiWFCKhIM5)iNL5&oiCdjhhNTD?DM_*B9Y>zUh9Rx$y9{
zMf*$l^DKqydHX)8vr)J{zjQy(O8Aqcj_&7~&g<r*_eHv&=Mv$1-s*myh44e9j_&8V
zQMk@u_w)R$aDBbg{XA>osnpT^Jd^ocAKlM0bzJxJ%!FrBNB8qA9M}CkE5~&|&*ac<
zTs_ZqKhJ57>wccwIIjD7&URe)^W53-v!-^B`<{;LexCa|uKRf&<hbtVIoEOB&vT*U
zx}WEfj_ZD&$2zY2d7kXJ?&o=?<GP>cd5-ITo)<c<`+4S$>wcaq9M}CkuW(%V^IYS&
z?&o>6<GP>ca~;?HJYV3r?&tYZ$8|r?4UX%6p8w$Zoau5sbX@oIe3Rq4pXb{h*Zn--
z>$vXc`60)3KhIA%uKRgbj_ZD&pLbmM^Zc^ox}WDa9M}CkzvH;>=lKK2bwAIaIIjD7
z{?c*X&vUcmuNdvt`Hzn4ex84IT=(-FUcl>s?&mq`xbEjU({bI;a|g$DKhIqq*Zn+G
z$8|r?102`=JRj}2?&p~a*Xz0N=UF(e`*~K5>wcceVSHWC{X8?rbwAI-aox|ea$NWG
zOct`f?&p~~uKRfwj_ZD&mE*dfXL2~}>wcb@<GP<`;kfSSSvjuzc_xckU-$FO9M}Ck
z3&(Xo&&qM#&of!f`nsQI=D6<XSvaoyc~*|=exAu=SYP+^%pBMKJPXHlKhMf>-On>Q
zg7tMj&&+Y%&$Dn`_w%eA*Zn+`BUxYf^UNIA{X7fDbwAI_aox`|Ig0glKhMl@-Osad
zT=(;=9M}CklcQN*_w&pg*Zn*T$8|r?%5mM#GkGlQ>wcb@<GP<`;kfSSSvjuzc_ta_
z>wcb@<GP<`;kfSSSvjuzc_znn^*<!{b-JHt<+$$WSscsux}Rru9J%i2nH*29`*~K5
z>wcca32d+Xd1fb)>wcceN#wepXXUu==UJT0_S-#7-WQxguKRf=r;_V_o|WUepJ#Cz
z+v|Rw+3DoEpJ#Fgx$fs#IsSf`XK^Om>wccuS>(E(XR?G`_w%eA*Zn+;v)Nwv^UTg6
z*Zn+`bIEl-&&qM#&$Bp>?R7uT>~Z9}pJ(!Ta^26fa$NWGES|vjx}RruKDqAanOs1w
z`*~K5>wccag>0|;d1g-}*Zn+`Cz0!Zo|WUepJ(x8w%7eUv!{^jexAuva^26fa$NWG
zEONHj{XDaa$Y+HQaGLka$;ITlpJ(NGChdz$*#3Os*)sAmt-qXH_w%eAFSY&(w*Q#c
zzqI4IT*q`j&(d+-&ojA<?R7uT+;QE{vvOSb^GsK=j_&7KIIjD7){g6bp4n4bNB8qA
z9oPLllgrs&_w&ph*Zn*z$8|r?^a|F|{X7fDbwAJAaox`|yOMQuKhM%}-On>w#rC?N
zXYRP}=UF+f`+26TSx5KtEF9PUJZr~wKhJE8b#y<^(sA9-GkF@@>wccO<GP<`<+$$W
znXX|S-OsadT=(;=9oPLlv$d?F`+1g*>wcceI=0vSJafl&KhMf>-On>!&pNuFXW_W+
z=UF?h`*~(pv5xNNSvs!!c_vS1d)?17cU<@LtQ^<<JkzULNB8qA9M}CkYsYmz&+Hkj
zqx*T5j_ZD&$urqr_w&q!haY!of9ZanmE*dfXZozJj<(nRJPXHlKhN56-On?7HtXnq
zo~7fupJ(zMw%7eUbH{Z*&&qM#&og~4>*#)-h2y%PXYIJ|=b1f^b#y<^(sA9-Gbz|!
z_w&ph*Zn*z$8|r?^cvRD{X7fDbwAJAaox`|dp_&vex9Y{x}RrqE!*pUp1I??pJ(N`
z?&q1lfOT{~&%$xt&$D)1_w&qN$U3^8XX&`^=b5~S?R7uT+;QE{vvOSb^GsjNI=Y`{
z;kfSSSv#)#d1lwKj_&7KI<EV9CNE)o-On?3T=(;=9N%@f?*1x$DeKG^UO2A%dDf0!
zEbX(GvCcDvmyW+ucyc}4>wccO<DZfCmE+$Pp1z!QekZ&Tp2~Gh_wy_r*Zn*z$8|r?
z+Hu{_Gr6G~SL^G3o~h%ypJ(Q{?&q01uKRfwj_ZD&rQ^DvXXUu==UF?h`*|j>;QVzz
z&(v|<&ogse_w&ph*Zn*T$8|r?(sA9-vvOSb^Q;}${XCNmoWJhpnL4ifd1j95exAAG
zx}Rs^xbEj!I<EV9{=d@B1x}B$y8jOs5m9jgFM!sLfEKlc-Aw{PP=|2W2n$4|t-2GE
z4T&b3b+bXBwH+_D+6n}!6+!J-#iI2R>kW(6fvQETcD>en$7<E8XrQRn8=ZH~`JL?f
zof+u=^M5}dvipALJZGMH-e-Qhn|=AFCJvuxLmWQObd{e!e4ZI`_&jss@Oc)*;qxqs
z!{=EMhtIPn4xeX396rx<wVywHo*8lYJagjkc^1Us^DK$O=UEYl&$A{DpJziHKF{=*
ze*W-zX2c)X-r(KuZHXVNydZvt@{;(p@{0Hil-I<sRNg4Z`wgyFp1n%u4}O#Kg7{~Z
zSH!=E{=|Qc{;&4^AN(j;hl2Ryl~=@9D{qKjpgj94-+vbUiT^436Mr506Mql-zsC3f
zB>EHo7Wxyv3;l^7c!Yl4yvFx`wDN-ZNy;nY=PPfBKUaD7+SO_F!0Y=W<puF;lvl*x
zrMw~japl>yt6l$ZC@+ZLsk|Z%pJziHKF{nr-yc5Df;fDh6><1H8{+VJX0P-8;qxqr
z!{=EMhtIPi4xeZCdfy*D&w@C7o)vNUJR9Qhd1i0${o(U0h{NYu5r@ySAr7Bs_Se2Y
ze4Yhy_&h7(@Od`G;q%NY-yc5Df;fDhJC);oBk+0dA`YMDB60XUcN2%tbL@>WAM}UM
zbDTJQo>Ro(^PD3NpXW~E@Okbc4xi^DariuU6Nk@p>~H-1;qx3P4xi@~arivvh{NZ(
zlQ?{yyNJW*xkwy7&)vk~^BjAVpFez_<HX_foFWdN=NxhPJa-a@&vO@X_&gVh!{@o1
zIDDRCZ}#(t&vTqOe4bOp;q#m$4xi^v;_!LyA`YMDBJtVw7yYB}Lv|B~&vWd0KY#c<
z$BDz|IYk^k&pG1odF~_*pXV;(@Ods0htG32arivP-s0yEpXWGn_&leG!{<3i96ryT
z#NqSYMI1iQMdI*zroWYWUekT`ObI^Eia30p`3=4vKF@|Ye4gc7eLZ}h+1osa&$A{D
zpJ(xRz8*f$^mfnT^Q?%&=b695*Td)85QopRe5bF6&og_M=kR&f#NqQScKLevJkz^9
zhtIPj4xeZK_r4xJ&xSaBp5=RdJ$#<odp(EGvnCFoXYoE?51(gxzvu9IR>a}+%s=4k
z;qz>W!{=Gv=<DJ0%s%Kje4aIN_&ke$@b&O{rkgy6&$A*9pJ)CdUk{&WLmWQO^25F!
zKF{nQJ%`V;CJvux@eyASpJ%E)htIPj4xeX!v#*EGvmp+jXL*aShtD(nC(q&Ytck<t
zS$x#j!{?bk<~e+x6><1H^N;&__&gis`1t}p&+MP29vnW;f;fDh6><1H8{+VJX1DtO
zQ^)GhmBiumtcb(s*${`%Gy8<^51(g2{AN9GMI1iQhB$nl*(ZH}_&f{Z@Of6m;qz>W
z!{?d(i|-GgXF(i3&x$yFo(*yMJhM;v{_uGg#NqR-h{NaE5Qon*`?T*5pJzcFKF^9c
ze4Y()_&l@E`2O&D7R2H6tcb(s*${`%Gy7NHA3o25IDDQJ@x3NxKR3h=Q=TpQ{u9az
z;_!J^#Mhxe@k`PFv%ddT=uaFz&x-iX=uiAB=>Iw2|912z4xeX596ry6IDDSj=Y4<p
zJPYFRc~;6R{eBES&-@G02OK`nhB$nl<rjTDe4g2tJcrM-CJvux@o&B!KF{=J&*Af|
zh{NZZf5q3s=h+a4&$IlhuZPbw`<mzQdDg_?^DMsZ>*4cE-|!qh&x$yFp7}R@J$#-G
zarivTfA{t9d1j60@Ojq6;qxrM<?G?|O#k6Ie4Z6?_&oD(`+E318{+VJmf!L9@Oftc
z={bC!HF5Yni|_h+_&n41JcrM-A`YKt{(WB$pJziHKF{*Md_8=g*$+I2&$A{DpJ(wy
zUk{&W`jO}Gc~->X^UQDa_3(K%#NqQSf9&hw^UQwYIeeZqariuo-M$_^&vd)z@Of6m
z;q%Pz@b&O{HpJocEdN{T@&9SU=h+a4&ojT%*Td&o5r@w+{nXdP=UEVk&$A{DpJ(<n
z-v>U=k~n;x4RQE9^Pl@Z@Of6m;qy#)`Fi*~3*zv3*2LlS%>KvsfzPuf4xeX396rzd
z7rqaCo)vNUJku|IJ$#-8ariuI;_!K9zw&+H^DK$O=h+a4&olqE?*pG_MI1iQ^c!Cf
zpJzcFKF^vse4g3ez7Kq!C2{yX8{+VJ=INB~D?aX*BTtm?yDH)*Do=a)`ty|+#NqR-
ziN8eav%P(v>y($o-=n-C4xeYfkMHwst*?mxQh6GQ$l3?47e3E|IDDQpariv5`}jWa
zd6vZC^K6L2=b7*4`@rW}DaX%`@Od`G;q%PyD}7K8pJzcFKF^9ce4Y()_&l@yeSi2o
z3*zv3R>a}+Y>30>ncdI#htIPh4xeX596ry6IDDSj0lq(co&|CEJS*bxc{ar1^UUt=
z`@`p15QopRA`YKtLmWQO>;b+%e4Yhy_&h7(@Od`G;q%NM==;OxSrCWMvmy?kXG0u5
z&+I_oA3o25IDDQJaritN;_!K95Ayxt^DKzN=UEYl&$A)Ee=d2LjrsnW@`Cs(<rVQM
z<qh#o=zoy!U!p(pYtWzgF7zjUEBYVo`#0!M{4Vq-4xeX396rzN5Z@m@&q8^Y<N=>&
zNqo!6`gMo+i<Q^J;qz>W!{?bEEc3y6;q%Oh!{?b3htIPhe&6=X?&$YNCGkfpuZXWy
zUK3xVydl0`d3uPS|7FTE;#VopiQk~SApQ~MCGpXZ;iK!Sh>w0u81b4oe4Y()_&n1?
z{ro4}r=va@@w1fY#NqQSh{NYu62C(GRK%}WUK5AUvmyR@txpeYKWQJ>KR-~O5r@w+
zCk~%yK^#8Mk~n;x6><1HYvS;EHpJocOo#gU!{?b1htD%74xeX196ryIIDDQJariuI
z;_!Jk#NqQyhxz%#=a~_Q&od_upJzcFKF^Xke4Z6?_&jUn`2WP=^Gt`!Ji+1f%!$M2
zSrUiOvnCFoXByp5?F0Sc^UR6E=UEbm&$A{DpJ#f6?+>46P8>eZk~n;xHF5Yn({K6y
z@OkFM;qxqs!{=EOhtD%T()WkYGbaw8XGt7B&zd-Vp6R!JfA~Ce;_!Kv#NqR-i63*O
z<YCHufA~Ce;_!Kv#NqR-iC>QXkMjND^UR6E=UEbm&$A|e8~PvN`@`p%6Nk^UBo3cv
zO&mVYbfoVOpJz@SKF^Xke4aIN_&n25zCV1PIdS+rOXBc(*2LlSOpo^c;q%Oi!{=EN
zhtIPn4xeXwjPDPhXHFbG&rQnV7lO}ofjE4gC2{yXE9FyNI;8}k=WgYA{}_Cp+3(0a
z+2>guEgV0O!{?bEE4<eJ@OjqC$Cbn9nI0$guT&17XQli|<?wkn%GWA~&oh6#^kJW8
zp*+`m_&h7+@JhkwSyMfHp6Pd`KkDK0%#^pcRri3;b58le%Hi{@s2)Dg-Bb^sXLgL7
z_h{_{pXZs%;lF~<v!HtTJYP=r@Of6s;oF4IvsotRg{KZa&-_^7sE5z99QXC`c{a*X
z51(f?`o^+-pg(+`rE;t%e4dNSv7YdGrsdKn-%Az<KF@rGaO`vVJS*j;lqdK+vz1bx
zDL>>K$@yG4Uian7r<Cuj_3(KX%HOLTKF{np=?`BYe4d4J?0@(?)A3S&r1pW&GgprF
zfzNZNa;y)0o;B6O=Q*}Y`lB8`&s_Pqo)<pPIpq&f4xeYKJXa2%XRRFT2A^j`_3(LS
zC&+wI51(hQ9R1<*EU6wo&r11}&Idlv-O7<~@OfrWkn^G*KF>MjsE5z9qI&o|cT+ul
zp4o}ge}&EmKF>n=;mYCjEU6wo&zkDt^K7Vo{yhD8?Ibxb`org$D~E3rKF?<<ho2BW
z&pE1x&-0a351(g6_3(Lqi0a|<{G{@IbRFRHTvU$rhtD%TQLYPLci{6Zl#gp4_&h7+
zM=FQUb5S|=8+@LPa@-g2dETKMc?+LsdXmfsIR>BSlydZe&$CpH{RW?Bqa67FpXb<<
zr9b+>=Q*w%^M}tfSB`c2+}eBgdFH1}fBgM3e4ca4;YIvOyMCj;2Y9)1_IX}K96rx$
ziNojlCgSjU?oy6@3!mpAariuU6Nk_9fHUN}_S4rLKF=}Y@OeIz_+ER<^*)05Zz(@Q
zIqsL^m5&oYSNW5OKTr9Ta`-v_O!*w~H!0sq{3FVD5&xR<MdCkKzMJ?V`)F>QDeJ~Q
z&q{fw>v@jW*UGWqwkmIwv(Gad{l!uHz`lK#){iU4{k5n(SI$1qN;$qSg3ohNIrc4l
zp6Mxa-eo#}_&mpzWB%}Yo~j&Q@8I(+lxNxpKF^Xke4Z6?_&jUnx%Pq2Gd)%22@aoU
zP8>eZQaScHe4Z~O4xi^MiNoi4HF5YnuOSYf=NpK_=lN#h@Oi$CIDDSFh{Nake&X<X
zeuy}Hp0^N(&+}H|@OgfQIDDR8AP%4BSBb;t*${`%^Si|1^ZXHU_&o0*4xi^;#NqS&
z4RQE9_gy3V2m1j&&jX0V=Q&0kKF@~|htKm7#NqQif;fDhM-zw7a~W~?JXa8h&+`ey
z;q%Oi!{>QAarivf5Qoq6JmT<qUO*f^&*u<_&vOHD_&lFW96rxE;#cl3Ieam3_&ooJ
zIDDQjCJvwH%ZbD1c?EI!JYPi|KF@23!{=EMhtKmZ#NqRNJ8}3tYvssu_&n3oWIuz$
z=b00S&$A>BpJz=RKF@Tv?+>46P8>eZk~n;xHF5Yn(>cCBe4aUR_&iJE@Ojq6;qy#W
zzCV1PIdS+rOXBc(*2LlSOy~Ok@OkFM;qxqs!{=EOhtD&e=ljFwnG=W4vm_3mXH6VF
z&vd@;51(gF96ryIIDDQparivbTHhZ&&zv}Xo+WYkJZs|cd8ViP{_uI`#NqQSiNohv
z6Nk?;J;V2h&od_upJz!NKF^vse4go<zCV1PIdS+rOXBc(*2LlSOc(h6@OkFM;qxqs
z!{=EOhtD(pp6?HzXHFbG&r<n&_4_*bJoDd|KH%_qra$l;KF^vse4gdAd_8=g`LjKT
z&oe#8bND=K;_!Kv)4m=)&%E#)KF_qy^Mf8FU%zVN@OhRO`g-_0^Yxy?=b1Km4xeXD
z96rx-#@EB=nQ!#`-8#>7k>~Jv*2LlSEI0Xj_&oE?p2O#vp6fY$o;7j!Jj>_#diXr^
zEuO>YnYMZkpJz=RKF@O2*Td(TZ}S{J&ot*be4aIN_&m$!`+E31^LfwV^Gw@4htIPn
z4xeYa;OpV@%y)PWpJ%$*bND=K;_!KvFYxv7dFGdR4xeYb)N}YeYvN<=U*L@X{-nIj
z*Td(T|Dor()~7%6`~u}Q@j3K=p|6L}Gyh}HEA;;p&u>J3<%Q-Le4be;_2BS%mc-%n
zY>30>nZL;QfzPud4xeXwv9E{Evmg$iXH6VF&+H|>4}6{_aritN;_!LqFZF%k^Q?%&
z=b8T0*Td&o5QopRCJvux_A=iGKF^Xke4Y()_&oDJ^L^m+tcb(snO^Se;qxqr!{=EO
zhtD&6h3^BOXGt7B&xSaBp822qKJa-~#NqQyf8p!l^DKzN=UEen&og_a?*pG_NgO`U
zhB$nl`Q^S3e4Z6?_&n1Uz8*f$f;fDhHF5Ynvnzcc_&iJE@Od`G;q%OQ`abY^R>a}+
zOjr4O_&f{Z@Ojq6;q%O{_I=><EQ!PC*(g6<a|}Mu{4b>sIDDQJarivbt9(6to&|CE
zJZs|cd1kNnec<yfiNojF5Qon*|0~}IKF^9ce4gnwz8*f$f;fDhHF5Ynvuk`G_&iJE
z@Od`G;q%O2>-)gxSrLcNGhOTJ;qxqr!{=EOhtD&+&i8@Ovm_3mXG0u5&-``14}6{#
zarivb>wP_Zo&|CEJZs|cd1i0$ec<yfiNojF5Qon*|7+g|KF^9ce4eTD_3(KX#NqR-
ziNoiaz0vo9&$A>BpJziHKF|Dbe4oP~F5h2O#3z-fH~D(_JPYC%YJE-oGUeHueV?n9
zm&D=oY>3~Y_4)O_&sUXK#P3j^-Xisx<`{gQ8FBbLbK>xM7R2H6EQ!PCSrLcNvnCFo
zXG0u5&-Ax`{_uHb#NqSIiNohv5QopRBo3cvMI1iQnmBx(4RQE9(+z(9@Ofs$;q%Oi
z!{=ELhtIPl4xeX596ryQIDDQBarivbTmAgu^UR3D=b00S&$A#7pJz!NKF^9ce4aIN
z_&gip@Oh@U`T4`=nGuK2Gbaw8XF(i3&yqNNo)vNUJZs|cc{ar1^Gtu|=MSG}MjSrR
zoH%@*1#$R1OXBc(R>a}+tcf4n2FvK@(}wsN%G2BZ{NeM=h{NZZ6TedX6w2{_gX@)7
z#BaiUh<{dj_70g3`g{-liNohv5r@ySAr7Bs_D<g)KF@+Ue4Z6?_&gip@OftM^8MlS
zEQrJBSrLcNvmySiN6G7$?ehKM^DKxTc!Yl4B>rgS4e^tdXYcm?&sSa$e=hnHe-Zi<
zzXtvP-uHhO`V;>+`V;>K`V+qs{omvJ-~UKihl2PK$}8e0C~t_Lt2}$}DQWb;{@kp*
zAYLl3h`&a8L;Rh}v-h3i`hQ$`LHwJ_E8;&>-Vi^qopAU6`@G-xhtIPh4xeX596ry6
zIDDSj2Yi3{JPYFRc~->X^K6L2=b7E;`@`p15QopRA`YKtLmWQOu@6dryl(_P&vD}L
zc}@|B&vTAAe4aar!{@n+IDDRq#NqSYO&mVYv48OMhtG4IIDDQ{#NqRtBMzVEPU7%+
z?jjDK=OS_VJa-d^&vWc1KY#c<$BDz|IYk^k&pG1odF~_*pXV;(@Ods0htG32arivP
zKIG>QpXWGn_&leG!{<3i96ryT#NqSYMI1iQMdI*z?j{bO=h%n+{NeK)Ck~(I6!F>i
z7y6@|nIjIL=T74AdF~<(pXVZR_&j$LhtG5DAN~B{^BgA*pXU^D_&n!`!{@n^IDDSF
zh{NZ(NE|-T-NfPZ9Q%l$KYX6!#NqRtA`YKtshoYDSuOp+;q$DC!{=Gt?Cat4Ot*Lr
zpJzoJKF|E0d_8=g4RQE9%a8hc_&l?Zc@CdvO&mVY;^V#^KF{>ep2O!^5r@w+ztz{n
z=h+a4&$Il5uZPbw`=saadDg_?^DO?w*Td(TKIJ)lo)vNUJo8WcdiXpW;_!KvpYiqZ
zd1n9WIeeZqariuoMPCn}XZoz?@Of6m;q%Nt=j-9~Y>30>S$^Kv!{?cO!E^XLYvS;E
z7GL!B@Oh>$c@CdvMI1iQ{NH>%e4Y()_&m!m`+E31v#)p#pJz=RKF{K-z8*f$^fk}n
z^Q?%&=b3-q*Td)85QopR{D!ZG&old`=kR&f#NqQS{$1+v{Wg4_6><1H8{+VJW{vLy
zpJzcFKF^By)Uon)tsxGdXZ9`MA3o25IDDQJaritN;y3Ggv;Xk@;qxqr!{=EMhtIPi
z4xeZCZQmb0&w@C7o)vNUJR9Qhd1l}7{o(U0h{NYu5r@ySAr7Bs_Mg5#e4Yhy_&h7(
z@Od`G;q%PC>-)p!SrCWMvmy?kXG0u5&+L1?KYX4Aaritd;_!Jk#NqSIzVG|*HK{)r
z6F*FOMSMbeLmWQO?7w{fb?8t0QuHT&75Wp0&oldh?|(D;6aNbO6Tcn(iNoia{m}P^
z&$A#7pJzoJKF@|Ye4g2lq<_`@be|G@o;7j!Jd4|WJ$#<&$DYIISrLcNGyjRNhtIPi
z4xeYa+t<VAnceO=e4aIN_&kd{d_8=g>AyXP&$A*9pJ#rjuZPdGAr7Bs`BPsHpJ(<n
z&*Af|iNohv{M^^W=b7&E96ryAIDDS@|M+_NJR9Qhd6vKM_3(LSzw{hF&zd-Vp2e?x
zJ$#<&*Pg@YSrLcNGyjdRhtIPi4xeXvx37oKGfSs-J0JTWKF^vse4fQf<kCJ+51(h+
z+jIClE8_5Z=KJ`1_&gip@OhT|`g-_0v-@}spJz=RKF?x5Uk{&Wy07Q(c~->X^UU}6
z_3(K%#NqQS@8|2`^UMzL96ryQIDDSP{e3-rp6LO?@&9SU=UEVk&$A{DpJ(<!-v>U=
zk~n;x4RQE9^8<Y!_&h7(@Oh>O`Fi*~3*zv3*2LlS%*K2l_&iJE@Od`G;q%N7@_pd*
ztcb(snGW{#@Oc)*;q$DC!{?bD;`_koSrUiOvmp+jXZ~Q{2R_e=IDDSzA-*0y&w@C7
zo;7j!JhO-TKJa;##NqR7h{NZZKg{=m&$A*9pJy70q}m7eKYX4AariuI;zypSe-D3{
z?{lK^lKA<`8{+VJ=7;+}FVXsn_;t$D!+rgGlo!O|^Q?(~TkEq&_&&c>UJ{4Tvmp+j
zXZ~Bh4}6{#arivbBYi!5o&|CEJZs|cd1k*YeU9p0&6MEtEQrJBSrLcNvmp+jXO{W?
z@Oc)*;q$DB!{^x$htD&6l<yCpXF(i3&x$yFo(*yMJhLNwfA~BL;_!J^#NqR7h{NZZ
z9qIeS=UEVk&$A*9pJziHKF{nZ-yc5Df;fDh6><1H8{+VJW{>v$;qxqr!{=EMhtIPi
z4xeZC7~da0&w@C7o)vNUJR9Qhd1k-k`@`p15QopRA`YKtLmWQO>}cN~KF@;q{<-8~
zMLbj95MQM{d#vw2rMw`%3H^ze=ui9_^naZ1zYG0|--`ak8}uiB7y3Wm_lM83AP%2r
zMI1iQMtPRx0iS33UFi=FpJzt=#p?6SiNohv5QopRBo3cvMI1iQnmBx(4RQE9(=mSj
z@Ofs$;q%Oi!{=ELhtIPl4xeX596ryQIDDQBarivbGCzO#JTv0(dFI6TZGVg!{T{6#
z{&3|b@k!+s@w1fI#0%vO@fRph$NKqSp*$mgz4Dy+=+}$g{E3hLT7JY!;-kNo8S#qv
zUhOnSye2;Swra#1;-jY{p2q$BPgkB1htD%7zC-H^;+HEgiC?e0A`YKtP5g^m-w?k|
zd75ZHX&<<M;q%Oh!{?b3htIPh4xeX996ryAIDDQparitN;_!K<Nk4!1JTv0(dFIOT
z|AWKlSrUiOvnCFoXId`jMIZP)bK>xMmc-%ntck<tnO6Az@OkFM;qxqs!{=EOhtD&u
z^!?%U%!xnn4B6);ariuI;_!K<<9vVkJagh((VsYco;7j!Jk#;MKYX4!@lT^aariuI
z;_!K<RlYxbo;mSj&eZiG4xeXD96rx<g6|KXXHNWb^d}CVXH6VF&-4V}A3o2V_-*J<
z96ryQIDDSzMBg7i&zv}Xo+WYkJZs|cd8U(mfA~Ce;_!Kv#NqR-iNoiap6L6-=b00S
z&$A>BpJz=RKF{<d-yc5DoH%@*C2{yXYvS;EeqTBKLhyOsNgO`U^kkV2>f!Uul*1<m
zpXZ!%ygv;-&q_J_JhPLfKmNV~KF?BlJ^CWkKH&4rS4;i4-~^v%sr;47;q%N+k@_Q*
z!{=EjU#lEG&ssVAJR9Y?*2CwSohtp|m4eSRSB`r4JWHyF&$CkA-d5cMKF{6C4^|GJ
zXLg#L7xnOY&M8Mde4dr^qqPrwp0_H8{|Y|OhU($-+<)|qO8Y=Pe4d$d_%`A5EY6Vn
zHF{q7JZt5shtD&e<?G?|ER>@jKF{hYz8*f$^i<(kANV|{lw*D1^DLF;<nyf8NFVHT
z_&l?x2`}}!;Pb4MXUY#bM{>Saj(xIR`J(cDwH`jtMmf9<@Of5e%X#7JgU_>3j{Ogx
zXL*j)WB<eFSu4l-z~?zOCG}Vz_&jsvsE5yUC)LB}Su4kV3ZLh0<;WBGJkz;y-dxuK
zKF?e^)(t+-g6iS(tf(G7&zkDt^GxT-dC?y}&rJE0&IdlvIpxSV_&h7BhtG32)x+nR
zoiFD_fA~D-l%qd<o|W<yIv@Bv8|8;9htD&umHw!Q&oft!diXpGs-Hhk_H9M=@OjqC
z+2{Fn<?s{2=ee8e;q!dJ(`BBhhtD%pj{fj@o<#NVc|Jw?KDrL@c}^+Edcx;fD#zCy
z_&gis<Jt#4&+Hj8PuxfFc}^+E{(;Z4P>%ZuKF@jO$WQn@OXbK(_&gV>4}6~KnSTGk
z=UFI6KEUU>Q#s}XpXV;+m_K};wQ{W657zekJZ~T1H?`|G`Z+h>DDyl@*V8<o%Hd1=
ziPpbddGLG^H_s<=^L!FF&!=+ifAf42H_s<=^L$<;*R`Ksmw7&ko9C0bc|M7o=TkZE
z3-f#uH_s<=^L#1~o=@WD`6O<hPvYkJByOHh;)k?1=4d};n`GTC(RG_pUMbI%pQF51
zj(xaQd87O!t-k{OH%ou)=XWU|SC0E`QF*TXS=#5v$}8pge(3@G%KR6VW8Xebd3vs#
zcbWEis`7E=nEw{#rz*$S!ON8w$}{bAt@4ui4azIxA5dN^&$Z7-m8a*O+7a;2DbI<2
zOL?gr`~2t1Uq;+KpTy1cN!&c2#Le?b+&rJe&GSjzJfFnP^GV!1pTy1cN!&c2#Le?b
z+&rJe&GSjzJfFnP^GV!1pTy1cN!&c2#Le?b+&rIKWdC44nCFwYc|M7o=acxc_m%tW
z5yZ{&N!&c2#Le?b+&rJe&GSjzJfFnP^GV!1pTy1cN!&c2#Le?b+&rJe&GSjzJfFm`
z++WuDV&dlcByOHh;^z4zZk|u#=J_OUo=@WD`6O<hPvYkJByOHh<;ZjMd~TKf3~ruJ
z;^z4zZk|u#=J}lU{mt`9+&rJe&GSjzJfGWqfAf42H_s<=^L!FF&*z-)Z=O%$=J_OU
zo=@WD`Fy_bZ=O%$=J_OUo=@WD`JDIt&GSjzJfFnP^GV!1pWA(Z^L!FF&nI#7d=fX$
z=YsEVo=@WD`6O<hPvYkJ+~ND1=aaa3K8c&>lel?4FZTV-^GV!1pTy1cN!&c2FYx`%
z^GV!1pTy1cN!&c2m-znX`6O<hPvYkJByOJ1OMQRyd=fX$r}Fpe_jTs^yiEFlo9FWn
zJvYxMar1osk*_z;=L<bI&*vX|Zk|u#=K1^+UvHkz(sT2CzR2@~+FzZHevYV#o9FYz
zzTP~aFY(+wpD*>?JfFnP^ZBQ~-aMZ#^Zea9&-7=Wo9C0bc|Kq6>&^4|3eU~+`RAUS
z=aaa3KL5hko9FYDo}1_Ma?j24N!&c2SNMAKd|v6fc|Lb~Zk|u#=J~wJ*PG|_YR}E{
z`InxX=aaa3K40bQ&GY$c&&~7sSDu^alel?4U*qe|^LdTu=J|ZB=jQn&KGy!l&gi}<
zul4oj`Ml2aT<g>8JikDBO?(dhU+?S9^Z5qPEA;<s&u>J3<%Q;$c|I$t2RF|rar1l<
zH_zuAeIN6D5;xE1-}rj-d=fX$Cvo$9zRCA7&nI#7d=fX$=bL>W^L!FF&*$~N-aMbg
z&GSjzJfCmzea!Po+&rJe&GY%UzK?l6iJRy1248QUPvYkJByOJ1xB5Qj`6O<hPvYkJ
ze4FoMo=@WD`TRRyZ=O%$=J_OUp3k@YKIZu(Zk|u#=J|Yw?_-`%;^z5$r>{59Cvo$9
z5;xE1yL=z>d=fX$Cvo$9?(%)i^GV!1pYQhd=J_OUo=@WD`TTp|$2_0J&GV`Jbj>mI
ze7;BefSc!&xOqO`>+8+)N!&c2#Le^hKHtYYpTy1cN!&c2@ArMo^GV!1pC9n`=J_OU
zo=@WD`MlBhG0!J)^L!FF&*ukyAM<<?H_zuk_<Hkv5;xB$ar1oM<olTClel?4iJRy1
zL%xrBK8c&>^TWR0JfFnP^GV!1pa1ClnCFwYc|M7o=kp`Jk9j_co9DCk_2&5`Zk|u#
z=J~wY_c6~War1l<H_zuSzR%$gm+!AC;*-kLKlys|d=kG<>uchdDbGIY`&_NOByOHh
z;<sph{xRR@tI8|lcPLLEm-<X|%sijO&GSjzJfFnP^GV!1pTy1cN!&c2#Le^h&wl>q
z`6O<hPvYkJByOHh;^z4zZk|u#=J_OUp3htT{LS-8+&rJe&GSjzJfFnP^GV!1pTy1c
zN!&c2pYZcH&nI#7d=fX$Cvo$95;xB$ar1l<H_s<=^L&2N&)+<s#Le?b+&rJe&GSjz
zJfFnP^GV!1pTy1c`7eI{=J_OUo=@WD`6O<hPvYkJByOHh;>WhZGWz+nA%2GP^eI1o
z^L!FF&nNLKwNIh^D9y3!l~=@XQr-~%tn%#BG9UE$p7MhDuhE~lc|M7o=kqhZzj;21
zo9C0bc|M7o=ks5EfAf42H_s<=^L!Hj7CfJezQ1`siJRw>xOqN_o9FYhzQ1`siJRw>
zxOqN_o9FX$zQ1`siJRw>xOqN_o9FZMzW@D?l>J{2KSFs$`~>9<@pF}DU-11mqd)Ny
z{fWN@{fWO5{lDn@e;oaZe-r(Qo9C1Gfk(+YWMA_AAEUe={zT;!@wLhu;#-tw|8{B`
zJ=&+;<E6?A;;&O)5r41phWMwHXJ0<G>)Sr<9^X-35dW3(inw_`iJRy1E7BkD8!^u(
zar1l<H_s<=^L!FF&nI#7d=fX$Cvo$9e$~(4JfFnP^GV!1pTy1cN!&c2#Le?b+&rJe
z&GY#+KY#Ol5;xB$ar1l<H_s<=^L!FF&nI#7d=fX$=hyxG&GSjzJfFnP^GV!1pTy1c
zN!&c2#Le?b+&rJ(@bfp%Cvo$95}$2<p+EY5V~)6aK8c&>lel?4iJRw>xOqOm>E~~r
zPvYkJByOHh;^z4zZk|u#=J_OUo=@WD`TTc3fAf42H_s<=^L#3Y&-0MSY5q6TAKW~j
z#Le^hEnjb*&;Rh;JfFnP^Z9LGZ=O%$=K1`NuQ$)<e|m17PvYkJ{I0Jz&*%3%H_s<=
z^L&2a*PG{)xOqPR%h#Ld^9P=r=aaa3K7Z)z&GY#q&&~5m+&rJR`Fitw5;xE1kA1y)
zK7Zo5c|M7o=X1BOH_zwoo}1^BxOqPB@b%{TByOJ1|MvCf`MlF}^L!FF&*x8ly?H)=
z=DB%3iJRy1=f2)NpTy1cd6%y@&*%SmZk|u#=K1`EuQ$)<FFiNUCvo$9{>s;z=aaa3
zK7Z}&&GY#i&&~5m+&rImOZ`#${hoO~iJRw>xOqO)X<Y~OG0!J)^L!GYI#%+tA#R?}
zy?lT3d=fX$Cvo$962Do`o9*rUo9C0bc|M7o=aaa3KKJqc&GSjzJfFnP^GV!1pZog$
z=J_OUo=@WD`6O<h&(Z$~-#+mAn&*?ac|M7o=aaa3KKJwe&GSjzJfFnP^GV!1pZE3s
z&GSjzJfFnP^GV!1pZoj%driuIE{GqdydplKydiF$&-?lQ>(HP0rRY!mD)c9Ap3eh(
z|C`aD_*c-M`0eOV+&rK6_x;WDN!&c2#Le?b+&rHTkp5M-OP6>)iJRy1fxg~6p9gww
zo=@WD`FxPCH_s<=^L&o^dh>i9<hgl1iJRy1U|(;Z&qF*n&nI#7d_LIMo9C0bc|ITF
z>&^4|P|wZtN!&c25A*fr`8?Ef^L!FF&*x#j-aMbg&GUJ<uQ$)<!#y|8Cvo$9KEl_V
z=W`?mX&+VhXG-SzByOJ1NBVm6d=fX$=WqLZ^L%EWo9C0bc|ITI>&^3dgy-h@ByOJ1
zBYnMjK8c&>^C(|$p3g^nZk|u#=J|Y#uQ$)<?|5#WPvYkJJlfZr=aaa3J|FAr&GY#<
z&&~5m+&rI;_x0xa{9WPr|2NI^N!&c2#Le@0jPGNfPvYkJByOJ1WxkJjK8c&>^H^VR
zo=@WD`6O<h&vD<!JfFnP^GV!1pA){1c|M7o=X286o9C0bc|M7o=X1I5W1dgq=J_OU
zp3fD&k9j_co9A;RAZj1jKj!%)Zk|u#=J`C%_c6~War1l<H_zwszK?l6iJRwhm9IC?
zCvo$95<l`p{d<@be4i7Qm&DIk-Vis>=M#LNmuP)O{5s|7L|^|N<ppu`d=me*)@LXA
zKEG665;xB$ar1mW(f2XWCvo$9KFQac=aaa3K8c&>^U2Z&KQEZ)lel?4iJRw>xOqNv
z-`_l+#Le?b+&rJe&GUJ(?{A(@;^z4zZk|u#=J{Oh`<v&JxOqN_o9C0bc|K3^{mt`9
z+&rJe&GSjzJfElf{^t24Zk|u#=J_OUp3l>KfAf42H_s<=^L!FF&*$mBzj;21o9C0b
zc|M7o=kpBT-#nkh&GSjzJfFnP^LeK4Z=O%$`{$B}6>;-?5?`hD*;&5-l=6c3CiEw6
zo=@V}p#M{R|6S-${8scQZk|u#ccK4NeSh<O5;xB$ar1mC&yqaM^SMU)gPZ4*_>1BB
zByOHh;^z4zZk|u#=J_OUo=@WD`Fxt6zj;21o9C0bc|M7o=aaa3K8c&>lel?4iJRy1
zY(IbVd=fX$Cvo$95;xB$ar1l<H_s<=^L!FF&*wRQ{^t24Zk|u#=J_OUo=@WD`6RyA
zsge&h@k5n2#E(^;ru_U*SDq1nw(^|#4&?>$%axbJuUB3X|FH6!_~`8!-TShLkA599
z;^|yJ|NFF0M?51w`mue)bK;|Kn@7ALKH9D$UJ{>CUJ-wx@|yUol{duSp*)?}e$qaW
zKOa+`5&wqrTsi)K@H>^4#Le?b+&rJ>%X!hqJfFnP^GV!1pTy1cxz_hL&nI#7d=fX$
zCvo$9KHc{>&nNK*!jnndJfFnP^Z5+l-#nkhx1v9B^L!FF&*w9JfAf42|1|m&H_s<=
z^L$?5`<v&J_%UbdJ|}LTPvYkJ{5{{_JfFlbM}Okx`6O<h&)@g`&GSk8HuNWMo=@WD
z`TPUl-#nkh&GSjzJfFnP^Z6{_-#nkh&GSjzJfFnP^Z9Jw-#nkh&GSjzJfFnP^Z6X#
z-#nkh&GSjzJfFnP^QjzuA@h6^H_zv^%m?-6`BXmDrD#g#`BaYgr<vzddGLI$lm7Vo
z7V~^6ueHB<J};E|apmUuRQ^ik=J{MN_3hgcyN7u`m9JH9o=@e$^Qk=7dh>j4kpA#W
zndehE>do^>_2&6h-riQ-!#tnL4_0oT&(Rme_JMlyd@4u1c|MgNt$ob%sr&%t=J}+0
z^L%cU^P=87pUUCkG|%TnQoly~o99zG>do`H+1H!rQ#tC*^Z8s~Z=TQR3CH@F=TkY>
z$2_0PbM}00kv`bx=K0(zywvM5&!_TC`61^>&ezJZPnIiRRKBm)o99zGybb30oR#y!
z<7b{v<=Fq``P?S;*#GAFRF3sA&*z-fV|~o?sT}p@`J{UDd@9F%YMxK!$P@E?K3~q8
z>pGa{Q#sbnJfBo=o=>Vb&nMNJ=W|}pi~i>MR6eEiG0&%R<ePausop%FRBxWo?Q&l9
zH_xYX^f%9^@)bHC^L#2lT)BBZ7o<Px&GV@o_2&7c`uX!@-&Ry_o=@fQaK2URzpfm9
zLi2o5y?H)&$UISRo=@fIZ=O%8H_xZ?eRLhn^Qj!`X`WBz__|}BPvzs<$2^}G%RF%(
zndehE_K$f!mE%4#&!=+ar+Ge=BPY%CNqx-o`2xRx%=4)n`Cy(;<(Q9oK9yts=J`~P
zbsNRvzUlV6by@7g{hmJBCkLhdUoP{(froYc!70092FO14^*OSwPwC)vDAlj%`aC2Z
zP5g;kKSq42<6|j*nV--4uFu0#+Ue(WY0D2z4@`>>ZvUdGeeB)+nbIpdu1}VH_(99F
zbZFW{eO@<E|IU_=we?%5{(S@WFX{M!=?gj^ocd=2^`98v-*5ToygbjJ4%8p;j6FXK
z<D8?9hqe5my&shJe~7FPjy-0?+n>{ua(w+-+49kPzHwXLmA>#?8F7K~i%t~&1P!K3
zl^1%wcy*5L=6_haf!6KE-TWVz^8KWbbZ=iT?Q_h1egC($d@LOn*8lxl|HzxA{>IS;
zZyz_c{GhhJ((~>wINjRS>ysrPzBa&j5Ac1TIa<#{(;QvbSj$K2_N80$t~=K4C0(EU
zr%m?}-W?qMv3`DG`@)Wm8<(w5)6-8m<-F-NXPv)xdOB^GnV-36^Y(?A`RRqN)9bfv
zo1NL-R&3ZdebJU}7p~hfy<uV7{PyW}J1$A<w{4x<GP5wVVcBuZSFY?Yn%=m1cJuVQ
z`T2F1PS4CP%wL)|&ac}#GreKQ)~%PeLzX<7ZYvjD>4mdX^V`->Uo<m2z50yF>2()h
zGTBad%Z`QV?F;MX7f#-=Vg8iaGv>GLnA_eKObi~G?2gRt*t&Z5tl6a_rq7#Lj$^0%
zKOLLAhjFV;K+n@QTr{(NYG!`*=mI8|o{f*}>BmR*bfei%w*6M(Of>s@J2o`?cHF>B
zTt_#@(Gly%NA`3Z&3^TgS8M60c<i3W`4w5x)6J23x>?3!dOq7%OS<lP-3E@{^H`m2
z7`tZ6yxSDR1w;L<!_X<Zy9S#i^w*>E(hVHF=Tq-l?=W2EwrA0Y3))kRGG=n+anmz%
zn^&dFX6Co;dA4=kC2Q84X9q`>D<>wGRN6DCw5RJg&#ym!)8>r}-6H?~<n$?LpRqg<
zUEWJq_R`~f=?T4bVxk}SpKqf7ge!V`9M?-H#`|%9kBL>i)sy{;G}(X3<^8AZZ{5CR
zed|Bj-(#}B$@2b*tmwbUmHnqYuK$!1{k<pqd#~tk(r)3tt31AcCae0da$>yyoD&0!
zwY<OkivI4a`e!~d@B&Q?Ebhed{g*m9-hbN3ffYNh|5{Jz?>;f`;!O^`Op^mkynJA9
zObl$ii4*$Qc=^CfGK#Cdjj()G|K)bwSM-Kcpj}o3+J#e~T{s0Q;S_NfP7(K?u)B~@
z++B8{5>65K_mFT3)e=q-_n%V2DO7ixGf>(40n3XUaeosDr%)~TPr$MP1D5?Au!K{<
zvg-quTP<MOlL1RO1uS<?z#2}G4=k31Qz(~k3RuD^U=63p2NqYuDb#B?MLw`%5>BC9
z!YN=4r@%FwA|F^{4X04A;S{-qQ{Wm-fonJguHh7T7fvgC!zs`%D+2ApDbOyQ0+n!z
zxC^I<`%l;fODOJ=B2WpZi2Hj;IE88nr-=JcDd7~VyIcuW!YN?6-y-gBBH<LO<^Bm+
z!YN=0r+_7#0+w(JSZ=j|C7c45a0*!NoPaf)A|F^R38zpl;S{ihQ@|Qdkq<1chEu55
zaEg3j#Uz|Uxr9@|8cu<0I7L3N#2QYaUc)JJ38%m{oC4Qy3S7e}@GhK=>kX$syQ~Pb
z3#UN4a0*nyDdH}iBJMw77c8N;ONu}xoFeY;A>kCNC7dGeKc$3IsP1wlPzk4i<$jB}
zzlnrXsFwRDU<s#yC7c45a0*z$DPXzP0+w(JSi&h_xpM;6aEg3ju_T;Axr9@|5>5eY
zI7L3NxEfBOUc)K!ffbW*3gr?`0c$t~uHh8<z!GaXg?bIA$R(Tt*Ki74!zpkLr@*^#
zI=(lY0`0OQ&@P+;?ZPQg38#p=aEiG9gk7+N;w~uym2ir<zlVfVsFrYwxc`(APNBNX
zl|Ut&0+#zN;{GNQPN7=vpMWKt0+w(JSi&h_38#SNRts3dDPRewfaT5!Si>pufyI(=
z3gr?`0ZTXqtl<>-z~X8+g?bIA$Ol$T!YPzXI0dZX6u5>{<O55r;S}mMoFbQS3S7e}
za1E!xHJk$P!f91+I0f2eMW9_c1=@vEpb}0Ici|Lq{|UQb3B_Gf1S;Vaaeog9r%)~7
z6mkD4C7eQamn(rvI0Y>CTg3fMB%DIE+&=+JI0Y=>6tIL-z!FXY%dHl$gj2v0P65lE
z6R?I;<O7Q(;S|axoC20`3RuG_@`1(Ga0>MrPLU6+n1oX(mv9PL!zpkLr^pAESi>pQ
zYdA$N;S{)rQ{Wm-fonJg-i6Z%z2OvSmlc6_;S^{WPJv1|Mcjo`#Qi7if+ZApNfD@o
zQ^fr}B%DIEgj2-*r<8CC)m^RxD&Z8c+;0*0H<54()pGv?Ea4Qegj2v0P610e1uVB(
zz!FXYOE?8AcTT_>PLU5RmV{F%mv9PL!YN=4r^p8uSHmgPYdA$duwoKUp<Kc#U=63h
zHJl<JSYi#QP_N+>xr9^T8cu<0I0dfZ6nGa-6XU(<6mgdp5qJ3%aTib#OG5SVE~0w)
zz*)P1iRE2nL@Y7Y!w1?(P{n#lsvbUYUdgIh-{nlil2(z+9oWMM`bc2Kdbz10m&l4-
zGAnWkt;i*{BA1&ma>=d8CAcD&+bVL6uAT!!D<|O<2S|EFF7Xw)=2y>wp|#coiz76`
zdJYUNpM+Q(ASo8P##lU{Io5MvXvH<j;s}kho&%C)@qmU|JfLY74``gl1CnPU<|JAI
zmShQ7@+@G<vw$_vA|E)ZyhCat)JqTrEV&Y}=2_$eZ8Xn9z2;fu1LxH|3-yvi0c)NG
zu6JeR1AR2lLcQK&foq-xu6Y)?=2_sHXMyVt8Mx+I;F@QF>)jPN@+=-0S~<<LFhKJx
zaLu#8k!SJ1&{`wU!U*J9JTSC;nrC5v=2_s#vv2@;77q-qIPxrvK%T_|nrGnv@+=%c
zo`nO*Gk;)my6>%?E$x!UzX7zR-JKt3mvMo1cXyy&@CDl4l7V(<7^uWj#69mJZD%a$
z5UcyIZ=(MK``&Rn>fL{dl7r!ta#uy%eLab|e<pozE^TMh_eQ)HOOl4(avw+Be>rj^
zg=)D~Bkq4GB`ia=WLdxxp%M45i3DG$mh_3Ze}Z!RhiVPU$cOgTz^klxc<eK<jG8*J
zzVD5sqpc`G5$ZJ`BbTo_kq^Au8Y{70vMzAVr^p93f~Hfb?`{tN9;?y59=%;O&~A4G
z+J#e~-Bu5@3#UN44HIY=PJv1|Mcjo`#Qm2y(SLmsPO(Y<6-qe8>i(;dZ5yiPTepb&
zms-LpR`;J$!YNcsI7Qt5iph2j)pA!w+&>f9lc8F|DPRewi2K(>!YNcsI7Qq)K?$c&
zt>F~8gj3`Lud;?ytRGlL4X0Qy;S{-qQ{Wm-kxMv5KJaR5IK_Gir@%FwA|KcY8cw0U
zyL<h6tPoCtcDp0c?$!;o+v<UK;S^}MVFK;KDNqTgh`Vr#xc~AboMLtV1<H3$vAX{f
z<vXWPE!#HY{t3$FiPin5l<%BEwS-f|{il>49YeKj*NFR<N`8t8)v_le?!O!fr%)|F
z^aL#76tIL-!~=V+e<m7Ep^N_T7x}=etl<>vC7dE3SOWbKGS*8t1+L)~`Oy9vc(pa0
zVjl^oz%`sAAJ_;QPNBZrss24y2&X{14H;+`PJwo>cA#B21=?+xK)Y}XRKh9ZE}SCn
zzdQ-2Slxet5>BzY{}LsfLbYt$i2Elfn<rNHpHjjpR7*HT+<!_5r%)~1HRArIl5h&u
zvL_?%zZ|(UL$!ocz!FXYOE^V5u-E!$qTv*}XgEba@G5IK#d-;+$Oo1{!ztEFI0dfZ
z6#3Bp8hEueoMImdr@%FwA|KcY8cw0U+o}F-3<#${yA2s=7fyk8uXdnaI0f2mm_WO5
z3RJ==;x3#b?!P<<r&!&8ff7!!y8jX-oI<s1+lc!oD4Qo%_n%V2DO5{1McjW%38zpk
z+co0;rIK(8)v_le?!O$lGefn6Q@|2V0ZTYVJh0dLXQJU0x@b5>KJY4QIK_Gir^pAE
zK*K54OE?9t;S~AM{u+3-HJoA}38%m{oFX6C2pUeIzT2tvdq1R8#NC#RxXY)AyH`Bo
zE}<gswoSxcMnx<k)x*1#>fr+yDmm3tKX9p%R6X?r7b{s6>t!4F@PT>CcIv4gIIjd&
zte3><;REN@UljUxw6q&UwsGtuw_6V%czI>J#`@kjGPLKF+cwtgZ@R)fCA(t1gjWwA
zm}l=h0NVLze#J)ky<eD-x*B>$483M5TId-uv>NyoVm!ITSZt*^)^lKR=M8NEjk2Cr
zl4bFLhFQ;nq3xk@){a;rj~NM}R`1vdbB<^hhK^6_FU5wAuj+zl`MvaCky;Pcw(YAs
z85Ny-#l4JOc@JY(-pknI?qTe4_cHeQdl-BC;8<C&{;@bVw3hg0aCog&-OG7b_0Cz&
zJ3Lm-dqVG692=Um^zI*vV?$%@i^}i?-^0$8?rlNeXghc>=kA}lPV9txS?%`CH1}}s
z;n8x>42-sey)*B0QF6zIQ!hDo&trS;MjJbDH+B{(`3+m|dG)tbL+6#3qyM}(HZ&H0
zUEF(K{mb&fvE96S62z`&AVF+BdJ<&Gv3ox6z}Rk11L@QDmi6c#i(`Z5)gOU}*J>aI
zY(07sWXZ9i^UA#X$Ku$~So>CSc+x{DU^DAWfu#qB&Mk8r7;Oi)Y?+^I|I@FVBV{7K
zb|!yl_2`S-z_C5UMnX8(amlc7Y|pTfp>AkcIHto!YtZ@)dx!NMTQY2DlHIaW%RR%w
z{BdpVu=d#8=zD;XKXU2!Af4uE=*Wt}F)Ig;95;C6_`xHq29KODc%<DoL(^`<z2{K(
z!$a>XbVquxwL8*#t=*B{YweEoUQu^M_WK?!=mfN&?H$<Csh|tpx^DAqYYnBtHf(zO
z^z%-B+G*3LoqcL+KNS@!K6gUW4Qcw+-#h!{r?vm$(DYJOX?J_J=!~<UK7HDm+U?9!
z&r8#1tT|`($!n(1IsNqWPg^^^_T<%TP8*$J%jOH$Pp{v;qf?`%br)`%U&!+_)||Ea
zl<CQ3lgrxW+Oe?Rlj)fa>lW6fjjfJ#`wShDe%&mlN7u@SM<d0Tnl{eOZ=PM)$Q2iD
z-8L%~-3n~jzHNHby4ej|X43Ro=d=elY@VIov3+Jknw?*B>eMOIwv;0&Yb$4+nP1mB
zVW&@i#s!nUq)QVjSaSWN<qZQu$LZ+{w{O=A7+qglKi4kZ{LJ&G&p7k4v~k<q3|;c}
zzN_5$g89u0Vd>UB?G%0C<E2gTrKM%tFWtJZ?!xxt!n}OkgwNV#otd9Y%VxJN%q%;3
z^;yR(th-2`T{OF6*@ZhcZ`p9n<_&4t=-H-q+c%|U8!nw~`^m?Jc{y_N%>4Gv+h*O9
z>Gs(C%$9Yd0s7h8mW8yeTfJoqGncfVk0iV8v2EQhSvIptwYr-&v}5s1Mu=ZmM&R@3
zu5ZiQ?(4R0Uf-U2TidYxV_A0=>DaykX<4iL-P$UA+tQf}cU;sCUN_s?ZSi#T?8a^Q
zeBFf?&d*$oXInPU&fxQQz05%T|Mkhk+tDNCGJM;s_Ria9DXmff?|TQ^KUB|*r)lJ2
zzi;~=#;@HwZ=a>KRzcQ1+w%wf)F2b>CrigK?45Uq7Igek-LpM^@c2{PLqEIw?rk{#
zHGAh>@ihuC|NC?_C3vLuX*#?8<o@k{7=Pp5dHXD-8x`!Y7rbA~MxSE*p`)Vq(Q2X7
z$aRnL^*(v~ETwt`+s8%n!T#j+dro`g?j`d-df&XOJz6jHp*j-t$9eGadF}DvEE%8c
z_*}<lI-cjRI9=9$GAc#CLdO?69@mNU^Yy<}$FJ6gm+1IQbo_4Rqw%fvJ*?jqEgP-L
zXnvyy{MwuJg!uOn<fzOQpN~GiqWy2__?_zK-l^kvEiG<8hhHBbUq$2LGtYHGS0CtK
zF^ogoYiT@u@n3kbjJqES^`kC}(W?DyREhP6$2~nn#y|P_enj5ZE`8k4K3O^*zWw}V
zvH)wB7Pp`KZYjN=#$Thp{%dsnf=t7@;PnTn+fPRSW`u6{gntKM><T$Q*W)=peySbY
z+UspR{@sB?|BvIp+>RYh5$DIhbCBK3_;yJ5_(uEZ=%vPZ{QCw+>-a^ze(X=o8~fn9
z?bxN~zw64GuJ2t}{@<?uhcw>)T?F00o4Rg${=oV1@lG0#e`jEmj_22#Ue5H3cKoOp
zuD?_t{uUj7^qy09pJnuX^bb*tdX5vvc>MbpIE?e-<0xP8Ici29U#sWey%e^ebM3<h
z#=qh!S^qV!_apqXl#U!2|HWmauSzL>kQR`~PYjH|V!4c8d~Dao{^0RX)bYH2&v~|t
zf64_mwEG0(mwvSDSW<e!`(%9m45@rnd+hP;jf#DPTp#5VUi&4()20VVaxHKFJ%ptX
WoEPk%_LIKx*R7ZFXVL(An*J9&14|A7

literal 0
HcmV?d00001

diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_bnProc/main.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_bnProc/main.c
new file mode 100644
index 0000000000..c1737098e9
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_bnProc/main.c
@@ -0,0 +1,28 @@
+#include <stdio.h>
+#include<stdint.h>
+#define NB_Z  51
+void nrLDPC_bnProcPc_BG1_generator_AVX2(uint16_t,int);
+void nrLDPC_bnProcPc_BG2_generator_AVX2(uint16_t,int);
+void nrLDPC_bnProc_BG1_generator_AVX2(uint16_t,int);
+void nrLDPC_bnProc_BG2_generator_AVX2(uint16_t,int);
+
+
+int main()
+{
+ 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<NB_Z;i++){
+
+	//bnProcPc  
+	nrLDPC_bnProcPc_BG1_generator_AVX2(Z[i], 0);
+	nrLDPC_bnProcPc_BG2_generator_AVX2(Z[i],0);
+	
+	//bnProc
+	nrLDPC_bnProc_BG1_generator_AVX2(Z[i],0);
+	nrLDPC_bnProc_BG2_generator_AVX2(Z[i],0);
+
+
+
+	}
+ return(0);
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_bnProc/sauvegarde.tar.gz b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_bnProc/sauvegarde.tar.gz
new file mode 100644
index 0000000000000000000000000000000000000000..2825a0bec122d04be6a7da0d1784b41a4dc6b759
GIT binary patch
literal 9050
zcmZvgWmKHavZ!$a1WT~NNpQ&kAvhrfcXt>pIDrWS2<{dfg1bYo-~<>LoZ#;6HaLUB
zoqYSAbN0UX{HXP=)o*oGSJhfwPZv%2GbBdHAqWZeFyqN#zHhqc{9vn+tZH8~&ON~L
zd7we6+~?z?pK9~^RZZHZn~?<Fg{LG6pVI8}>>sbLA|l%{C=R>mc)iOstEomB-ew9s
z4*Ctg1td@ZIa!qjCRDi8u=t!$z^$(vS{fNAQ7h_{-wi7VN$nYEvIwbX)$2dLb6WHp
zn)P#P5Ll_dV}N*bm#=**q&Q62*x$a`+;--WIa6bwksptYwFVq+EIcxpae(f4-#J^%
zkv=_MR6Nbyeo_v}3Vvv4JAEYW<UaHhs=IS|yb9q@S4D4GawWd?np9+E<R<k{(Pz>7
zIkn4|Hk!*X{PUr>YL&OSC9d8m>xtldAx}c$xRz2vlw%=SbIoAw<63G*8ny#VOZiFE
zD-FqKl03v?S`yM@8j^Xrp9@M@hYH6JnK^Q5=jHS@=M}d!n5i`PRJ=5_3iLjCX`mLx
zrB^%kOUX;ES!xu>B@DQiFpk9~sKb6}=V8|=oo7Z|_gdM|$cYa+)eQ`4S05OjZw=(p
ze61XNCY4z=FRCWoIly+VXTln(q;OP+eCg<slB8Hpq+s_65*f)cdKrC3UW4mup&!D%
z)e2ucD6yMaR~@JI7%@MAHTT^Ft=>Gj_&<@Rj_M6TpU$=9W1eOvc|)F7x;0BBSCE{1
z+GO4`y_BoLdeQOcGCm&TVF#$WM5g52c{Cx^A@I9|X>-5XwV|i*?onYe#-x!Wz&fR(
zCF2Ix^`_v?Qe<SSW^K~ZfVU;b`inveZf{*B&)L0m#Z*F5jHsZc^PVN(t@PoqD>-wY
zry=*sZo<1S^5R=jcn8P5W*Y;>gYJhxk3L$4dsNPItLKw0_|Z*Qn~geo?dd|j?-)Za
z|7b7O&W$ugC;$!`9`z_w%sNYG+{(Xs0dxbxzD%iAHvd>3TsVD^aI4oI6z$N3+qs1U
zS@Br=769fhV@r}VwmiO-(Rw<#3pbiQl@X;;biie^+Nx}FRi76gpSuybyIu(oj~P0~
zNPJfiTZ8*EGImOODdtZ^q`%UEoQTD=8~TfyASTn8c#!efVHo~<yDHDOF1JTq=T0pd
zkw5BwWUeuP+7osYu4nO+RNoc=;QD$(ld$yxUB-+<{vYjxo$jXX&ZgZRAa&j~MK$`C
z@A4R1_F3{S<c}x}8{(_`Q_^BCP3`V}LvGx>E7X{_^3N-hLBGytKRN8W8yp17Rn$qE
zn@y+_7e+BA6zLDJwg?_UvU+B@P?{U*Q$utasLiGlJFLsFf9mkbeZ#kn*9?<#9;P;#
zL@Y*N|BR7xV|+07b2<_Bv-VO=25gW^cb-miS>c8lN^La455spGxoBQ8iokp4Hfv03
z_Cg^KyD@K#y_JCSqnvlE4P#d9>O3YCFM%nny7X!NSxZ)9m13&!tg${WgKec0F0$oc
zBZUKx+)ETTj?mUVDf5F06J^Rd3dLUyt`&skc2+kDEmtsI-l^En2P-=+<Kmh-IP8aV
zdsz>UfxKjl&1ni6l8>9q%8o%cC!#F_p3+7*i>G=V%aWR7pdMk1hKHbNSaku7GV|-S
z=pQ+Z>O?rHdhUDn`-O?-%nahB53Uj_P}h2=B>Cub;b^vE1^5U!{YE%u!v72W$P9cp
zlnjF2QcV=qnic6*leH*!-ruR?;NqBFZY~StxPAPcUm33ZNBce%QV6ja8tC#4Bwe{9
zydg3()v0K>xW8qZa0oVFNIYFKN7aK&epMv7tlZ-9xvAC<H|jU?T;Vs8npB+^safz7
zp%s0{__UQGo@uLki^`EQJ6t-`n{>!9aXof0Q-1x9ICBtWuA#|k7CkHa`l<r7JL9;{
zT6MH%W4++qK@|BWJ)6U!CwL+5%F&9gOTyMg^60aD_@aH!c3(E}L}sCY!*ku;lAu)m
z<$?J{N39+=GGNBG8NsmXqp)`Kb}4C7#16Ah>xGqAJ$#Lsrwzh#M5<48L-2<14{K8A
zaV-lsS$XE%tPv=7PR!Qq)BHuh=hfK3kd;L<U#)v$c&9v^BxkRmBT=AEEA5*@)tYaz
zZ(`!!@>pRHnYVeKpMZ;6M0>wMD|h7{piBWp?l2f6l~d?*DLArlxSmT|WntTVwj|AQ
z$#iCN6|!QmF@1Qkhv`5QoOCvob-|tl4Cl~1+hk25F)vkXO-QPXWBR(S`DSHV8Y}Ny
z=<_PaLs-ZTgR-sS?WwGhr7s&kWsWjx>d*G|YxXC)_K2p0FTVCAR>f1#WXtuq9p+0v
zfOZaTGSB5|^`2ghxKjyVO`&;rcki`LZh1Xr&6GL=Tl5^4Y&Fa4AbPIjGL#{DIKcte
z&fDZe$FM@mA1+Rh%#+7YNBLgAa9;1C(+IanZFn<qf@$0;gpj!DVngor$c0}J3eW3g
z*@1-wMaa_qKQ?zWQU@rWZ+j<sWK#s_h1rGdzN<CilZdjbqKKR6m$DM)dk?<_9qyiW
zrim869l9J|RNDJOUjMpz9kNI&-Y&6j;3c;m?r<!t%U<<|2_=8@bz`!U17OHNf4K1;
z%3@%J4>p;~+$x6PM5j__RPNLUJ>ANUMkfKINv^y%%~?e3^ybeiSPl<P`%OKC7ui9%
z`>8kh6ysB^HArvQn`vgqODiu$2}L#`zVCIu$}Luk$m+2;s#V8|WDvwW$5nr?Ink8y
zdoPpBtXXm-<b6i%Lw-o-nLqR-9traZ8MBAzx6!mqTg`5IA~HrD5oht|5HVFPGNNu@
zF=R4!`scx!AKXb6IWQ|Agfx+Uw#Vg)@2XWa=!Kryq<jGL5hMdmg$3>zMC&J4nJVvB
zfj%c5{!DT8J|%v~DaMt_*;j|0B-*d~O@;ER3YC?ujmuI{dQulm6xi4zth;@=a5=SP
z$WS9ixFX+)nf(r0|4tB$8m5`qwe5Ut*~d}Qg}qgk!3nZmQ&ax}Vng4lt9Js`l%>zG
zW9+<ZcMIBV8GVVgErPsV=j#R)Hm2ru@ZofjPM;a>af1=1&nyqSl~+50O3Bh^P<H&z
zS^L~RgQ@xP(=mq^Xok&%+FK^<l3i0#&XpR>K+R>zGjA}q>-^lHE!d{ZES&hsn1iU>
z1)VKYuM_*GmmqEFg9m*z%W~c&%h+95?C7twqJ@R#`fB3+g@qRWoY$6Zy6HVX6GnIQ
z7iN>mq>5qcd%1~q#!lsyh$S+o)OXHK;g(rIJ5mGNoMT~gbNMdzk4}yMrW?i?8e)@J
zX2I(bMSLj`I?4!DER%LkPEnQ*j>j<D(z7f}^PrI$Q|Jz0_2r4K*!3ps?#m0TTQsku
z5mGkP_XD`_@f-t*pBt)0s-@;Z0@O?!Tn-LJJF2D7-w*8qzz2chykWpWV%-r2j9;m+
z=g%a63OSRyHr5jfd`HSBP3#R7#dd+Z8Ym|&mpS3XPqa@uZrp(uSbYSao^h8E0k)}0
z6mA=N!!58zWNQPHwCVy$CF%pk8$Lz%5zru4;_AM_{n)rUhISo;|BB84QTuB$vRZB5
zXup@c>;cT!BeKLnNm?X9q!Oe-;$-Nx+OqQjoY<`=nB%B>Fv7j63@}K_geWtf8yi^8
zgAEMj#SY=e)~Spu!*nM4MXiHhmK1j>hwLGg3yC;m7H0Ay0_ph?fe3<#@WO~jK@8UT
z<Sf}DqtsUTv5<(e-nZZLPk2~ago6|i=9CcTRIo$Tu&pZNYB5WQ{%X}?&JW0W0D@${
zDfQF0)Q;1)(9Y9SuG9NM<T|J)Wsy95MWD-%Q0fJ&19J_OH33<_lW`lr6aP>@aIqiK
zC2N>_3@Y+I@};l)U4XlgsYtA<hj{+jG6731-#6=SzHefaeEgeyA3QYkMUZcB|MA!$
zU3+DKLivgh8BbLYAq2>H$jDJ5D1tz$UUq3*d1P0DRVdd0zXhO|T^k#T^na>C52cf1
zgVJHYg3{4Kk-5u+0Uv!)5miA0XdRv;{(ewa3{D~92Zg26^GjGW@Joo%^P|!8!$WaT
zxlZO|7|v+v`KgC|@ozX^yr8tc3yJm*@9|)OLSD&%L;rKj2akk&5gG8RybrBN%rbQ>
zBK#fmAFBicvf$8hgtos7_?ZmY_mcIGd(0}*f!`(6-J{E0$R84cP5Fum9T68o2+;A6
z(ea=l1`~X2N<<o|jUA$mqhZ?=9spu~2@p1AZY@G+u_;loDYGGR<J3g_A3Xl49gq!X
zu7U8zg7C(Q@Wu>&#tcS+vtoIutRfvE!;w7hP(AFJ%92$5#5eO1Nhw7nB^OGU4Mm<T
zrQa9xLoLRfMBRts@54ebt69NTZvSD)7yeVmgZ%$`TYek`tuKv%g`J<v<@qe}kp~yZ
z(*Oz0cxr+x1nS6Y?4pr9D@T3qD6Y^%@WADUj|5)i@HR3M+#kF6tzM)|odydkdo~Se
zXMCccvx0p}e~wD16Jr|KX4$0M4)Kbr{4T85!&DfmBgL9gSjREL9A4V?TsTU)_&N1&
z@0i*}C3{fF_~4(waVvmS+yN64?(K+?MH5&0e(=&vWUP~;x^mx?>#=>L;?+Y+BV8w0
zA7g^s(5)H%*=Apr=EQne(LQxESOi?;@-+1HND%UtJF?;KO|u5QB|OR|E-hF+9Q@^*
z_{4fLH${}Kk@d`u=zfc)_P#+L&BxLe4+omxNe2+MxfP$9W!pdbPSKh^%4x;G0Iq{7
z(x$E$>h_NRVsR%!nw{Y<k$+6Q&NTTx!_PThtM}ZNw~<J1&w{s)`7431Z8^Cr^!Dq%
z`YWvh%yZR@*k+#%+W#*gK2mgPv|@DM5hZ<lW94qEBgW=)gQtVQaBG_3_m5ZWuRfhO
z`<W|RZ`uXeoR2Yoa-7WQ9c&5;h#n%z3=L26$s-(Yd7LdcxGKw_U~71p(dscs(o$Sj
zFlzgq_f8D)<RDYT`sLM%sY~&`M{7_fJ!XxGa6$mi139<6W@qj+g^!m4-mOhhH!SH7
zv1)64)S3sl?BtN%sAX1WojYAxRhfnD;k3&r{N(c%S>6xEu6V}}Y)Z`h$$80JBE0ln
zYfWB?%&hmB-8z1QtVe`m8ctEQtbDbs@GRpgSz0}jl3BdYEd4{U<pe$n|C<r{lxb2u
z2QGUdv~)t(`VSZ8GKx}T3gI`OJ#_u+I^Uzc^hwFZT1fu7V=^RJU2;DcN%BBWWd0O}
zG4?*~sE|4J`2o6Wt)w|y+M2mK)g1hljX3I0ml>AyM}cT8E*}b7SF?7w)o<l}Zj$-z
z?x}S{F$p$GL!9H1m;K-9O27acZpo_bl7jHVLVFwCU^VWqW3Ho1F_|>Dy+=_5`2Ha7
z7hHui)!w}qCFXtq#m4chU}{yt3!xZhB}iz5dSOUUkGbm8{O7O2N<-kJwJqGwZiGu#
z>3ojBkoruX2uO(lx0OiX1KN;?VwY$0y5#=JH~w4+=ppex^jSrse3wx#*Yhfy1WrC)
ztzxzG|1oD|(tk7Oa!+lo!c|ngV9yB~1@2%~yy<hT?Xv_o#Svrk7b>P7YfliUtxUUE
zL)ZF1#LBk6t+RhzTi$TNM4dTWM6J)NDEfZyV37p8%>9wTg+;YXSIXeXwu)<OzT;vM
ziFwZ!Nq6$`jPQ=FeA-AX|1tYQd$5v7_)rKPbn7JZK#W9M?Ng3~;zMv90Hr~DgomS=
zeHRXg8j*OlwM;(rV+Tl%!BL-+yuc7wMp^-SeLqfGKPZR}Y76oFL)h<)xL7Nb-=ke*
zQuVCM5gB;_nNA_&Hpj#g?)d#4-GN-Avo9yeeq5dOzNf8%ysC0rx&t_dv#DZiLDB=S
z<Vu^h3FbtKkBH;XKPn?7U!f&qj)@>p20yt$I=SKX@BnjDQv5c^n&ApNw-K{l1Pme;
zz<2jp6-J<pLo|Oh4DFn|A6B5cAWv7Xtyd25mw|~{<0orN4hD?=wSqY)ALcfeS57ii
z-t6HckTMf%2}!tDgAj+l)WMc0qjt0S@i-uRQ(4>LgFf~Ua7fcv^L-O*O7tIq(S3i$
z{?ffVBgRsSp(8!;nS80Z4gug}F@e8usZ1sT-M_$P>)*j;q&U29V)xY<QB!C^f+Tw=
z>njOD<SflVWjs}hQ6>bq{FXK<dw$K%H!C0FNLUgjogr18NWA?mJ)*Y-l94H0j<N&C
z+-bSk;g1%yEYqKEqNv^YhgUW}*`zBNGTiIWW>GwR#`yi!E;&g_)-6cxd#(mb$%`11
ztv>{*47B1gbbY_nJ|%nTaPDo)v!^l$GmX6f=}o-=5zM{7TZ$8TCGLsV!uu(V=h<4E
z^vhN8_o0Dc+4;vcGviSZ@_P)W?3(Af2+q(%aE2~|GYpCFO#a0g9n9AqG&1=44bu6&
zE*)-wAXNlHFe4Cx8G#VYl<UmK5V>mVNmZ!3vB)ow+%y~dAuJTm-Jf@oexdr!8eQ$1
z7?B!3z1ly$)+*l@{<rx_z`3ibN0{R}CW`Y<h`3o=Y6V$ZXg{)0%CY>@BJ&aI|J@>q
z7}o??;!noq;!pgo;=!Tu|7wv;$p6tIu>yDK(L3Zz(K~QnVRYnRp#0M!@zDOQMM_A)
zaATzq;4-?rT0p$Aimtk{8nc1~(~O0q{e>5V$7SlVWhX3f=pq^dEzl8YfyR%9#t(nC
z+wzsNhVmUd`l6UGYA^dnvN>gq0Sl7B|5PO&DTKKkA)!bizDSsTzs^2AL&if?h2WD;
zRj2+oT=X5lLT&XMgJaw(K|#VQ0eb8zLCosxYu>J2sI7QnUqH<2Hy+gYo1HQ;;CvX(
zd+ayl#|cPR-<jL#{&NfBym4^ac0b^Q-^B-a4+(cWrt~CLfALNFb_6!HBe1ERj<y|n
zx|IGv%pbK3a~kykMtA^w2IodFMmiB9E(Df{5%HrD@gsR81d9Ac4g~)}MEphS(;N=}
z63PF|5v;O*i3H~Nw|0=S+W&<|W=rW05j^q>a~AawhJRR<@e3q{ju#t`f=CKNLQz6|
zQ7~01<BBoS@v^B^@QWKniyK}~5B!AYY!&<m+02)|f?5BUw>xo<FxP*kH_VZb&MQ`A
ziEq4GBqGKJ$(yz(O$Vz*Fis#JpI{D)FE99uFW%8a0D~DY^F^=WhUw3p?8OU8m+bpj
z?rXis9~GaNQp*!vpmp#PDN&6IDiythS}*8i`W>Oi5PdPH%j)9i;RcwuY^5HIX@We;
zvZ);;P@#l#fEc_o52Y(GN0J!O|Mqqq&wjc`FQDiwv7hx?A`@WZy9_k&x;mPk{koDB
zM#25O!JLz0BB8-{rLeHIb$*MU@88C-u_lNy>|DVsw`y07cu$^my}+POid3TBA9G-X
zJGtifPpUh5h9x*Rc}`kwSIgXvBhwxQ)oo7}keN7<oy?NQOkQ~-46|u7;MXt;5r6;o
zoe~%|we#`Lt;lf326=qv?PjU{{NawiRB*(lz7I##VAa~-iaE$gYTDS;pl;H3?=T&T
z+AmSis`YD)Vo8U_e}L4z?W*GxWA&4c_L~G~Pp0x_TWi~O5LNWW`PjwuFMpE9vy8G@
z*Zc`kn%Dhtw`AY4E9yY%c<~&@)b@sQ-(vAVREh%*6LlJgFuFMKy3SRsLmfYjoe%FH
zO!@Q|Q*grSFA<p1&9|a$z-njS;*a$f2m4nt$F7Z(;y2A+Se#Z(KUQi?0<XrB<Zia>
z-*KQV@_pBZ|MK#eKg+b2jnlXZ2Dah-J%vTA3RH@$$_<H{gGOg(MO-cs&^O)}8#!8G
zy*hOTVDeIb*6GL>%boL|G;>umYNW~jF6Q~O=BsAPit4Olwn#eY84+3Ze1j6?Nv6{o
zw*NGyX*#D}<d%F{&$Tza;Tis^hJxez9dqB~%SaY4-X%pb2EZ1!zg&2~7Cd;MP_TMS
zk{}>h4mSN_Q5C61td^dV9ovC$B9V^oM^5r_12@sHq~Ck<-FyrIv*C*b(R)KVD_mYS
zfU`aJh)15mo9yndS(DPH4R!&-jy$~j{@He7`D)V%YNmqmW-`2?+S}A|k#9zEac^B|
z$X^+LOCBZo{2b}$axWyMfL~bj1LOT$o0;4Ne6^)#LHO&Yy}G^hJa{Rudc((3q@zh=
zH<GhYgH=MQq5}A9MnD?HPL0pvnC&=DtcLTV@F|2n<OAvLi%HQF0}=={Vzmv5t4SU+
z8d}8!`6vm2vu7*-N-oONVX7~)GZsSI%QUpth++QK#LO}#-n*xlT@!9oyL4-5OE%W{
zC?T#(z~fYyj<t{Psv%#(itBOzS(m2no(%!RSbP1r*}?5v^GW$hxg<8-C!vig8WH~G
zzot$ZPd<BpJGfirdE_hV<klYP53~%nd=qCm>_VF->V7hq*00_3wq|jTKhj9aslxEP
z8B9yLF2E?*=uMo_u*=s}gw8-(e<x5B3baJpPLIkK?6w4-40K-(%qa<+N#lFFso(s(
zHixq}rcYRNm4<XfIXXE=|8Q6e#dgt%G;S$wm98hAUk+Fsa4S0%qbh$X?gXd+-v4fV
zpJFM*52bm}k5FOT_+fj#Hq^^e^W)c`+rH?W3UU{?Rnn!Ea+q|OucD84r<rWY)6=29
zZG1JhEpg${L%<X0=@9D$d^E*tP3k6=eM!FzIT$)2bu@rpbzG6mU3FY`T=o#VMJ0<1
zUM&o+dTT%Zz&j#6YEU^M^)bbK8d(2+@8hwvJi+@y^7Ov>kw{xN1}U~TLcD`blTMz6
zO;6?Ll1oXGs*TX3jp=KqQMG>8m8yXAbove6cL8vNa^9hDQ82(^7E`>y@1_bS3#<s2
zvOtH$4@QxDI9XJ?^4zlh@0-!CsjlWYR*y-paUN|3jT-l$Msc!gE}usSvj)oO<v(<3
z9J(m9JM{K{;2SOHYBFg=ZIWdin+EqLZZ?_`E3gI(3Dy7#g?^=ciqlYZl^tz~H&z2I
z3$AM0-gg*a-p47#!OMaLeciZ_eVLqIqe78>DIslhjw3_q<C#6nuVl0YhZ&KCv)U=W
z1vzzWG0aT3$P~E4GQ9;Wj*2$=L@_V+BS5ozzMweS@w$niU_1u+(K)@q&T28LcU=$A
zaU8jgK0e>RM4j?Bk!V`-2T5i4Dq~MKQcaI>@C=?YV~WJa@z#q*82_TnYUS{K&;s5)
zLkc~t%q8qudKb7C5stsJ6z6l-51fDKn;sX@j1qIAI#n=v4k9eb_I)i7UavkfLC@oa
zohhvkKUik$J(s82Rp6FwN)(i21+s)wtzaaGnMam9FQO_&oIBY1P$7ZG#ego7N}5_o
zMc0fq?bnK5KO)w0(L`)Lt%YO3T!ofqAQ9yV-f@2nMY-+B{_j@lP4uyhrQ^V!HLmbQ
zPXN`%8YPfQIi1OY$D#GCrEb%VNb<)(!AXK<f5MpdDG)SoTJZes0C9YZzIkf`q4}06
zi+DFfRtQf;Cq)$V1SG@AVGPbh-qxHs)ml$Ae+;+#Qnw>2@;2DqzUXy-mm#NC`p^!}
zdfTI>y-=cqkXWaS-qL;1VT4}fGA!Y(gU6F#x_Y~wM*HO=sBy0G)X-y}WOI$-2yG~n
zh6nG_yLYBSvQy{xSYG%LLCB@^YfpZi))`prrL4gVirnf682a%L{!}yjLchI53d>{f
z(4kjg0$4+11vq|ntl`sxE=~iE6(P)v8?Z>*ueAx8EUi3NJ<p@Ln4Z4MMb650xvF1q
z611Hgwp_qvc9qPf`+WD)hpB$Ce!|OF`|BHy%DFGg4#c8?X!|`n*f@MO>Kz~3#)9_V
zH0sn*Tu#|fBD=9QyHx=is+N6bTlob<aw8KBKi_Cak<zTmXL*`<=+~1Kj~}!tDNE1m
z+q!20-8sNr%eS5VvD;Bj8jcX$KGt$xcPzXdk?tLU&&3!?NHhc{<q&{@Uo=z_w|gr2
z<;%UV_qX>TyKxDhZqh;LGTJ}J4%NAT^1KEzFXJ^kalT4va<R`+JRd%ovQbUXClrOz
zThdX_Rj(H(?c3QpNC-Hy=OiSug>{DwkB2LE8j^MHR8AZTercY)UBYkZzfaK`B4w-F
zHzA#fTpy#c1(jOxet%NPBMH?c@0KPfezzB8iYLJbxhATYtqAmejatM-_C53%+kI-q
zHHVX(%Wd^*;rAuTm$jWnjEqPh_q$#AwwEW4s8SEj3WiV`SsosK9Tl}3ClRTkW&~A}
zy6|_*AE#iSuL>>F;xQ#QXdy59Zdc`Kp9R-R=ASzCtc&Zn++=fPQo=drT6Y3{GQ{#m
z${FrdCb!EH)Md@!s5LaV!`@KO2hq&?>zv=wCDmhdF$|A*!Q=GKD9u>>&+&?e*Q&xS
zvPp^)m>E^>b^-G8Sd{efSn`;pD680wg;?6j1<2Ydri=#Gdyg?;;v<{3DA8Z7u`55Y
zjsBdtM^+eLtx$-qmu`wSCcaN3o~}zE1==oj95*2kk_P~$t$lS1N2dhJP1Chb6qEeS
zjdjh~J9%;02Z-hi=?vq{$b+r_SpxoDDw!{s%4wnR<WY<F?-x`Dcw4I=c8|Up(l{Jf
zXn%v-z!Ou(6$e-xH?CHQb+0Gr&fzxeSHh)dLHDS$0LK0Bhj0gF3dp6nN2&Grg0i(O
zFFKeoFZzl0wwW~<98ioX#r@T?wQVo_TWBjKPRU;4*<5fiWFP1I;a#A6)#U;soS~Hp
zIR}EKiBM2)j6c!I6rdG6gWSq3*?-i8cA*&O{e$j-`K0u%_gW6BxB2%A^~Is=&*os*
z&oMXMIaxq;y#JzLJO!^%jDF$hv<2c0u0h<v%&0?xc>pb;Y~4Z`zPHvW+{g6ED#3Yp
z7gMRNzb5?<*5}p9_wTp5(e9U!ecFv8Zw5@VP<_m?gB&iX|9t43L-W~ro!lvjiDnyV
z%+8GAZ;mZu_|;%ZvNzTiZ*wZ8g>%fWg<G<Tv1zn7Cve#-lfI48^J{kH^o8W3z^Hbi
z%#utI{|N_6Stv6Hh_GET;(NP!<nQMpRE_NFR`&@8DA80Qy?EDCfVPua<Tk`<0EaJ-
z`NM{yIxR3!4it=M4?h^Ee4NQjULB|&`!c)x!6M_&a|)_HcJ+J*U!@N_3<7)nYSYNW
zf}H><K`0`~8JVJITMXu98w<YN*=1Zm)+$kdm}BFrPp7c595jCH7mP}G_O0$w;WcUc
z`=h|QS50id=FU+1N0{qXkpITqnj*k7&l#pGGIJH$Lfcez=QYYNyd4_?JV)EmJg=E>
zTo|qtmQt1Yt$}T%TVMe2ip*6r1z04qF`BigS){yTOVnWy?>2H%`(hB%@LILdL#S;z
z7pBZ(GbKO3Z39%ok6O`ia$vdA68^$6W4-LT)w4(Q;JC57q*{Ipt}_w@y`H}<1eK2W
z&yzNM)*pfvMz+-1r&B!wNWOn=b}LQ2n!y!61Zxuo-4Pr!!e7`EraEsl?6BF^%?oaM
z>bWVgJ$*k5=?t%aOa11MPwV{gP5E|tSieBH7F_Z{&)^|Y>u7j58bp&mNdX)IQ7w_)
zv-R3GA?GbJY&D5A+rSP3E&T3p25M%W4&$a=QmLI$xJDZtQ947HkH2rAQT3y9jPb5;
zt|PAT5Pi(ZyKN9Gju{_VvdDK(D7mzK8R^8*)cYsA<9>^8pT`jBpxQ<=d?)hd+hFc;
v@|&G60+C-AWiC(GO<>op-f=1)X$hX8q4<6HpHG)^uTL^qbqZ-073u!~h@QNW

literal 0
HcmV?d00001

diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_avx2/Makefile b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_cnProc/Makefile
similarity index 100%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_avx2/Makefile
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_cnProc/Makefile
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_avx2/cnProc_gen_BG1_avx2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_cnProc/cnProc_gen_BG1_avx2.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_avx2/cnProc_gen_BG1_avx2.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_cnProc/cnProc_gen_BG1_avx2.c
index c9b371038f..77ddbb6543 100644
--- a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_avx2/cnProc_gen_BG1_avx2.c
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_cnProc/cnProc_gen_BG1_avx2.c
@@ -3,7 +3,7 @@
 #include "../../nrLDPCdecoder_defs.h"
 #include "../../nrLDPC_types.h"                                                                                           
 #include "../../nrLDPC_bnProc.h"
-//#include "cnProc_gen_avx2.h"
+
 
 void nrLDPC_cnProc_BG1_generator_AVX2(uint16_t Z,int R)
 {
@@ -15,14 +15,14 @@ void nrLDPC_cnProc_BG1_generator_AVX2(uint16_t Z,int R)
 //  system("mkdir -p ldpc_gen_files/avx2");
 
   char fname[50];
-  sprintf(fname,"../ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z%d_%s_AVX2.c",Z,ratestr[R]);
+  sprintf(fname,"../ldpc_gen_files/cnProc/nrLDPC_cnProc_BG1_Z%d_R%s_AVX2.c",Z,ratestr[R]);
   FILE *fd=fopen(fname,"w");
   if (fd == NULL) {printf("Cannot create \n");abort();}
 
   fprintf(fd,"#include <stdint.h>\n");
   fprintf(fd,"#include <immintrin.h>\n");
 
-  fprintf(fd,"void nrLDPC_cnProc_BG1_Z%d_%s_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {\n",Z,ratestr[R]);
+  fprintf(fd,"void nrLDPC_cnProc_BG1_Z%d_R%s_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {\n",Z,ratestr[R]);
 
   const uint8_t*  lut_numCnInCnGroups;
   const uint32_t* lut_startAddrCnGroups = lut_startAddrCnGroups_BG1;
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_avx2/cnProc_gen_BG2_avx2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_cnProc/cnProc_gen_BG2_avx2.c
similarity index 98%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_avx2/cnProc_gen_BG2_avx2.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_cnProc/cnProc_gen_BG2_avx2.c
index 24e97ab5b2..76db309f2f 100644
--- a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_avx2/cnProc_gen_BG2_avx2.c
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_cnProc/cnProc_gen_BG2_avx2.c
@@ -15,13 +15,13 @@ void nrLDPC_cnProc_BG2_generator_AVX2(uint16_t Z,int R)
 //  system("mkdir -p ldpc_gen_files/avx2");
 
   char fname[50];
-  sprintf(fname,"../ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z%d_%s_AVX2.c",Z,ratestr[R]);
+  sprintf(fname,"../ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z%d_R%s_AVX2.c",Z,ratestr[R]);
   FILE *fd=fopen(fname,"w");
   if (fd == NULL) {printf("Cannot create \n");abort();}
 
   fprintf(fd,"#include <stdint.h>\n");
   fprintf(fd,"#include <immintrin.h>\n");
-  fprintf(fd,"void nrLDPC_cnProc_BG2_Z%d_%s_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {\n",Z,ratestr[R]);
+  fprintf(fd,"void nrLDPC_cnProc_BG2_Z%d_R%s_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {\n",Z,ratestr[R]);
 
   const uint8_t*  lut_numCnInCnGroups;
   const uint32_t* lut_startAddrCnGroups = lut_startAddrCnGroups_BG2;
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_cnProc/cnProc_gen_avx2 b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_cnProc/cnProc_gen_avx2
new file mode 100755
index 0000000000000000000000000000000000000000..5e123291d134e638721f46037c0203266555eafc
GIT binary patch
literal 43488
zcmeHw3w%`7wf8<V$;@PcWO#@mRK^M#5JD0jqJj<~fr$o1M8y}AkW3z$SCa_@6&wxW
zlHwz@YO(bJ*m|wCEm{Snia|8squ$i|YKt|#xIw&as)&5n%J*Mu?|tUX$xP6D?{~lN
z_x(7Uv-VzV{nuV+pSAbdXPt9~n+l5NIt)YT%^}VeR13HQ%#wQ{{F}I{cr!$r2#8a~
zcZCa_RQv^4LR6MCJ)%r&>QQ=5&=ma5a7e}sM}P~Oj+ShpsrHa4wHMn0swip7WwNR%
zJZA>s$XDMIu7VbGLDQ?19~%_aII0pZQ{gfdPSY;sn5O#p=-B9Qk+QeQ5kQUV0U{!w
z_c2Pkv@Q53Qby%l7jYFdzy(c{;VuS_{QRbyPbn@`?Ir7%UUht$s;Zb=UA1)j)XCLl
zld7v~o0=yz&zL@G`qZq(x~yD2Zn96h^DexUThjgLM~#ke82%^*NIrGYl(8x9P5bUB
zYdiRpC0qZ#b?-fk2&?~4{KnhK&>WILdt?&+*d+WZN%&_c;pZmd7lH4`pM4t&Mj}54
zB;lWtgfDO&N~znYi^lqfs@h1oD6gvz*NXb4NTVoOTGtQ}<)zhijbTx~yrC)rqSQhm
zf`%F+B@K~KO-WU)2!$$Y>S`4yB<2+r=FJJ^X60s0BkvuS|8$Mc5&eg8MJm{uPO3^H
z=~c2Sj)aQ2M6u~sJR&2Ci@8QT!t2d%;hRGd!b}UF;zn=T7Cyz5-ey?%*7+h};akT`
z(89O+xxm8LW1HGoY~ka8&8^tN_nKTGf-RqTg6mRSuk?#xYeyutrv<`b%k!Sy79|vq
zPHTY5(Qy&%GsXl^qIxAM9q2xaZQQj~r!G6t#r36Br>;8C!SySt?xgw_t}moIb<Kf|
zTtA=c)FlVnxt>RL>WTwVuAfbH>VgCHT+gLC9r}S{u1}yk9rA$%sOS7gVcYMQ1l!&Z
zwtU#TU{T?oj_9m_2=3YCW3p%UIRVkL9Eyj^Gsff#v3)r@=+fY%dXQktk@R5ON6Q`8
z?A{K0+%bo)d6q;+yEDc_iMO3<T7TCOC-j4D&jojVd|uG#3jY2`6Tmx2G1&TA<j^(2
zwoZwEU*V&(?zzH`upE3TkUgv5$Tgj*Yrrx-+fDr&Y?(FUawtSjHeDEY>9c;!^3Xrp
zb<Ker0Ld654m5(2jo{6n&|Kekr0vNWUmrbM-qt!3B)F%bBQOW%_7v=$BWc%M(3WRN
zNi?U)f@9U_b*;pKn}rZ_n>|4=dWK>rWx)->bww|9WNf>OE#FoU-MN@dw(XJXRnQC)
z_Xm>8_+VQ>Pq1ZWk7&wx_D=A7{_sy2-HBar9VBhLcF>Hw)4=Z82T4AKtSHfmrf55f
zMkI3u>N~rjVY>1wvcIRGJNsPoP@BA99O(k%;Dz#_4as_wSm&sIkgR>g$~1dqOup`s
z>89U%dQPGP`TVPxx1&sN&jg_7TF5(FDOQ7>t=|J_?`&-V5uL4c&QOcUS`$c6AM#Yw
z$YL@w&TMekj+m&OL|%(%x{2CLqQ6P6j$~{Vt2;7QKZa2V`&7-?+Lf`5BO~M2&$V=n
z*>xnftzh4F7w{0Zbr~H-*RF0iv)|rRa0q;HpaS@Hm+m7McZvc_H_wypbgvV;dQ#h-
zTUT%>W9#YyI^>M49maDE$g~26Te^!TZ+YH}q0)1XMU-WVHjv1luo>#oB+dN#AF;E7
zv8|ffOSWFOh+-Y;n+wrX2}MB?-7iJf1O0Wu+v*6T&@dx!YF|xDmvr5>!06j6!qTv<
zSH@XHwqEfjY)SV@;+F3IGHJ*B)*`ZX%*KQw?wD37vUiNxdR*U(u-HjAPs^*+!LuN0
zDL7=btUTn%SaXLZv}2>{9a0<y#qvF^G{yG{6c(b;ZJ@9Sg)RpQm!Tj?v{;L-)S|1k
zXbB1or%MN;mTFO%7L}vWO=s&!u%*LLL+Kq%R2Ei};WP{fmwY(g0UPFUnrDffBS-k`
zbfdi#Iiz;2yYx`7tt)7B&{c)@J;6y^$oe+?-*MZp1kv=kw8C?%Et=l4h-}gHG(>v}
zcr|_SCLE!~iOzNNd*l7so3U+m0i6Q&!PPgSvn&nen`fE_;3XE3EzV{@)B+z`R`wzY
z=;BP4=^7DJ<fzM#HY`5!+>>NTZu%l-$QE{;5UH?pW~`~OTzX<*cN$Jn&wWrtNcrJY
zHO1C<QFxmQV^PSb_&W`SEmX)vf#Yw2)|sevvb0XN*2zVI4NlcM)3weFt#h{4nTY~7
zdal+9Xq`N*ldpB=qL8n{*P+69cPxB~l_Y#=5tTfAo05g^S%=N=^;oV5+g86o-G)#}
zbVW#!phVF+-XgL^YdS<aTCZ2ps@mMOu7IO;*ZU5P846U@dcwid`gtriY=QcSMHGua
zzEa!)kqT7jvS^YZy;kBWNUhzGBuKwH6mw*dIb!lC_D<o}cy3I|SaWm2AYDL;M_>a1
z*bR-b6r1mpDiuCNfun3c3hl({LE#B1e2fA|>nA9%@?TM4<z5t6`BM~F`49@Md>938
z;s^??{3Qyk{1pnU{51-!EO7Q&*?|H#k%9s%yHH?d4+^a8MS+zEqQJ`OC~y-#6j*r(
z3amT~1y&x80xOR|ft61}p<PeaP8I&|$HJdjNy6XRZ}{JtEd0;@3_i$-b71`Jy{nr-
zQBU7~80csE{_ImWlW0JUkS(ytHX!~9lo}8RqVPZ75z7p&ec>sbA|=@rex1b++sJ6Q
zh-@RH2_iKz5Ub1Rv?QLwi=+)29jdqbo5KI{_n0Bu6z=2}d32;^tXYa9(k;fO@M;<z
ze}aw9){RgY(b>8QB)hY9GpTpBJ_u6W+4@tE=FZlifnat15Xi%wt^W#wCHuo50Q?*T
zfJZ<8_yq_6kAeX3OAr8l1p>gYLD0|^5C9$n0pM{E0Dc1kz!M+<JP888RuBNTfuN!7
zAOJiC0>BOs0DcPsz|$ZAJOcv2P7nZ|1wlg{AOP$F0pK|h0Cs}_@H_|rFMt5h2?D?#
z5Hz$G1b`Po0C))mfR{l4cm)K2-+=(|DhL4o27-pVKmhnX2mr5v0PqJ80A2?H;0+J}
z-UI>QEs%DcB3f0YsB!s0Y+Mp6$+)CkLh{SfUCGAf=D)!UIWB$nap??>$GF6rs+a~P
zwVZfOwM5!TG$>mvBHN&>gh&s{)v-aTyoei=+7V-Kye|pXR<He)kB5D+4a_erBHO^+
z2ay_>u8cJe$p_|dqzxLF%F+G?W`U(eO0~%wy0tXkuH_baV7fEblu#_FsbI9Jcn>Mg
zhGJ)H01615*&qm=JW}s$odbf<$p=B`6o4Q`=Yk;Q=7Dr{wo;Pf?atOh5Cq`)Ab?*0
z0(cP!;PXKMzYqlQi$DNh00Q{MAb>9f0sIn>5uL4zKmflK1n|p10KXgr@Wmj2UjYL6
zl^}p$1p@fhAb?*30w<P$03HGXych&<>IcASo&vlS1n@Etz{4PbmxBP#tI^KZO4I<S
z<O<-|f&hLU2;kKqfY*QkUJC+v9SGp{AUKBaffOV000MX;2;dPAz?(n-Uj_pBauC3q
zK>%L?0{HbHfZqVp+}U~~2;eJ00AB?H_)Q>yM?nC;83gcKKmcz60em$G;H@BVVhsr3
z{{jN|S`fh7Kmh+f2;l2L0KXLk@Y_HDza0edJ3!z>I|$(GK>+^&2;e^i0sKx7!0!S9
z{B97ye*^;f1`xpS0qIcFP-@?4h*<x<)6l4c@JUWX!}?A`v^>Bx)Y1Pm^w!60BhfVU
zl|^KmhTelH!8D}2uuVhK5t@dqz9g82F0eFcn}+HwBHJ`{DMV@-^7K0mO_Vlh8d8q-
zHx2DP5bGG*`rreI)Gc0G{4_+@6FFaPrD<q~X=6{%xhTK5TcuU~sWPqFL#c<h)=xkv
ztt#f@)*We8r=(pj(3WRNiPNf7;It|gkXB8DSmsIp-h;&9)7Y(RC0Q)3%9bgCI)Y5<
zwCWJ@i?|CVw}<f7wCW=8du}A76(muU>@f4_N=d%YB8sI|n@O|_qJ*x%($03-sPz1D
zGJ>>f2l`7Ls!W&;4$8DD9gj+@o<uC9Rk<Ie)~UooT2=MPyD%;7zWeXm?>#-cQSQ0l
zWbE1zTgH7s-VTKiGOapLrd2WQ>2iiifYPd{MP#iBWT5ViSQw7D5Jq0L*pG=8kmxrS
zQ7o;xmP8w*C}~=i&R<+w6{ESI6^k{k+5!9K8SmZC-C<3tS#pRnt=eM+JSzdVdBJ}X
zeE!fPip>j)N%UgEW^@8EK{JajwqiqmE!kRW5yd*Ri$qHkiaZM-n%CEZ*zIuu8fKTg
z^HG0YVx}A8dgbR5lc-l-wTNuJ@|%P$>0U|P(s>qhwvH*Yh-@8Gm{7zWlhxM=>KL>2
zxW3u-p&mWEcEl#X+o^;1Lv*aP>V2g63>2|O!H}7WH3|qWn3NKI0&5fy46ZWC3`=IY
zWLAIxP$`*Jl6kFUUI)^wuCO|N`W{Avg(a`BeTEI@+kS@44`D;6PdltJ^3(@1M(D;O
z{tBzor?|jwWYgAleq6{blO_^{%ug&LTgXHq(ihkkG=L+d>y~oDa)CAdpzEvE6?uJ)
zbLHUsv9oH6DWAm^TTFcpl)Anmg-R1*-x-i2>=kL=;-~HU8W&<qEY8?Mtc6?TWj<1<
zw4l{3#wPCl6k=CG5eX+seR2{r7X?n3PDNoYW$ve=Q0zn@F7?Sel=@_ybG1$Y1x^Cx
zp}+?7wa#3v6Vy8AYn>t#*x-d)htk+=XQ9?vq;)PsVXZ^OYriSfJ|R4W<E$&m12t<3
zH7<k?cbg$>%^4zvO5GMqp~gkZE(uB$wEHb0ThP7?kqX*_$4sHB)^!RsuK7Gm8@52L
zu!wAdS_F{_)PyNi4${*lo`Tfc9Z9YcPrVz9y+P=Ixwdm$jM)1NL~0&PnnLxF;*(HB
z0QMq`izz+&DcvSe;SdUbO79;=AxecKDDaafN_}z!QR<VGDfP+9;;2$~puoy0D6p~%
zg<`VoL4lRMC`8FJr9N3X9R*hQp}@*RQ0O4kFcessQlG3$sZUlu2?bUjjRGs5jDnvm
z`%z%!@1nrUV^Lt`(@<dLOcYpo0t!+61fky)YM=0@*D{i)YOE>LxbXkt9W(s<O`-be
zHYx52SX@MIk!BJNh&L=E+kn^sk)Fk)@L$d1$`Q*f9+yI;NU@|)<NV09G-ewa^DQFV
z$jF6Ajf|uzR305^(gux=#3|IcDf}n<Vxz-0g?B)tMn}>V>O>kHKY}8nh;F@SQV`Nz
zcQX~}hMQCKbg$h@9J<Y(NFn!Q6e_83FA5xT_oKk5jVLf`GYX9QDGH2w2n9wxi~^$`
zL4g~66a_~83I#@OL4i?^qrj*qP+-(n6d1J~1#WZ)3XFOh1xD>efl(bOFzPuJ81*~~
zjOs*z8{LZnqh3ORQLmuDs8>;7R2K@2dJP3ey^aDm`X&mDdK(2s{Rss|?L&c4e?fs!
z-6$~XeH13@k*JfVAI8>Fv7~9Ak=XxQ>h5G~shU5TBhi*Lm1`It16WVh_dgO(lV%c)
z#0xAU+eplYNRPx@Vk5C{-c+rp@K~H5XHZ-w8;ke;F&6%|vAD}3vW>-uAW~xyBO`(d
zQ7>*{iaZuqN*gp56K751#$tx0McY`M$}RG83VGUM9FcA@wwwymSR4RFnZ?8{FJ&>2
z_gYBmGK-14*CN#FWfl{8ugg$F-ixxBSj{g60f4fY09*+I0A(=&xEcfi%3=br1Ox!e
zVxl2-NM<nsSPCWpwCDqXvX}r+783x<Vgf)}%xsy(1c0)b08kba0Lo$lKv_%xD2oXI
zWibJuEG9gw2LXVxm;f|@06<wx03sj&P!<z_Wgq}h784CMg8)ETOaQJ20f4fY0Ne-y
z0A(=&SOo$AWijhz783x<Vghgr2mqAD1c0)b08kba0Lo$lKv_)vIHTV@VxN)u%^zpP
zT_gYSCcH?RM^uk9w$QMQdz=w>VY)-wNHi>;u!wBK@*arvuv{G*mWlI-(h<7PvHFtW
zKF4Wk&^9nLEuz?X<D|kMh}6JL`Z$9J=7(?CyQ{zZoMlp*J0|uxqm0JePaskkN!#O$
z*uZQe#Re#LwhF`rLdO6>=r}+SI!+LTP6|kKXKN}*duOW)1R>`J>F8|rfFSbHK!Edt
z05<>xxPc(R4FUl!9R#=x5a4_uzzqgLvqM0D8wvv4Fc9EQ00C||2yiEY05<{zxRD^h
zodkkrM}Yu08U(oSfB<(g2ykOSfb)X@cM1q_-vt5gR1h>f76iC)Ai$jl0^I2!z-58}
zHy#AI2_V3o0Rr4akmAnPNg%*wfdDrd1h{Mv;Br8K%LM^$3J7phL4cbEf@Y_K0Cy$`
za5F%FI|~H3vq6A62L!m8Ai&K60q$H7G<zNhZ~+kDW`h8i2Ljw25a9AbfGYq2ZY~IL
z^FSWPz@+DzF7-g+<=7>fSV__y{Z9ldlU<@;dJWFViC~0GcW`8HUHt;ZUhK`txRHOC
z1SJ~zJ1ipG$bSGLeXqDGzRlR{HqM~&F}>z632)i=H~9>)v|}6aXIezI0Y4fdHQ+J)
znv-9NKl^>cZb@>_*ebQTKWtaxM<7xI9*-*MN`fP2#nG7j<jv)J8t^wmv9opKKap<6
ziv=JEn9U$#@nQi8;^wCyNR#~x1mW`#$fC~He+5AlJq%Kf7YjfTZ;yZg{tFPm9|ZyY
zmmq-iOU-z(05!n3fB^m&2;h%{0R9^gIPnAs;7@`8z7+)UZ6IiUI|$%UfdIY(1n}R2
z0RA)x;Lm`-33^Ez@Ml2)?*IXO7YN|bfdIZ61n}oU0Dl1l@J<lG_kh5Oy&!<U2m<&^
zAb`IN0{AN+fd38z@K-?q|2Gi8yFdW{JqVn54Fqs{c^vT9K>&XP1n@UO0DlVv@V7w#
z|04+Ce*yvg&meGO9|+*@fB^m%5WwFB0lXUo@b^Ffe;)+!4?qC_5Crg#K;XoF5WxQ(
z1n?dZzz=``{xJyP2SEV;1O)K^00I23Ab|f31WxpV0RDFnz&`~6{4)^14}k#wISAl~
zK>+^(1n?sufd4O$Vl~~k)pTQdje=N7rW?#BBubK+vc5(Ux9+&=RWvWBo6+&v)m_~f
z`sy``{)hgF(ng}$XQoADn|)4!D8afzc@cMGt{tIuN3q411nZ7<zvJU!Uu@IR7K_L>
z4c!Hinud}-zvOjCwX{Ju1j^C=)*WBJ5_85j4V}s@@(qFQ`DJVx`V~z>Uy_a6?&|&W
z=+W)nU_5mxt<l=v!lx&n1%DQ7>kYPjxz5w(4YoX&0<Th3@OV`4?2lcmh?OLGQu+;^
z4au%mC(Glb-tZ?39(_OQ!~JSMnVmOZj`dUQ-DZB!^$&~47C_w)=>W3i=anZ30!ZIb
zQeP&!p}fG-o-KarEh1a|TndqjpTYg+=O;=VmLBUbes;bT>la)6d;pQUj19?HLw9rf
zGKTS?E@LlK{OmAo;Q2So>iKueC-vof3fdh=>J<FIN&7ofXn%Jq?Kik+|6@1p@Ac6B
z{xsTe^wNIw0NVd_AnhL-MEi%+Y5zzD?H~2g{#Qe2zhxNhA0JNpCq~eI>q)fVKAQGB
zPNx0Se%kM(7d{I*GHL(ZMA|=}P5aKNwBI{}_AgOFrQnqS?O&z$LJPVU(Ehc>w12&r
z_HS0w{_T3&|B3Q01^c43|4TdVyEoGQ{VlZru!HvdyJ+9jP5X~~Y5$2pTC3o%lq)Uh
z4bcA6V%i^y8hZ-9Lg$Ku)7KSz72J@qEx({0akP_oZF_ot`Ys;0ClXBMbM+Nofd49Y
z)${yp{Keh!`?T4Y&u%+9`?A8e!?Q0fY<pw&qN3Zz_4xhx1nss-L@y~C|547LgS-Ce
zq%Zn<#_h#<ZvBtQ$r)o-Q>&t=?c<`h!}+jrblARN%Wflh*1@Ka=|jJ(u9<!H>}zH(
znH}2QUY@1(KiiGTgT4*y`zavXJJ!yiRp5Vdi(<Bkeiwf~$KT&!>@>_T=i=`Q{PCxT
zwg%`<?1#{OQ|d?44B<>kb-6uh-l0b75KpSZVWa>noVq{;XigI+k9H48OYsc!xCeR%
z4)D6Y-a&59fPtwl`ZNmLzyT?#sW6u6bYa6j)dkBgr&AqfYKk+_=5RR31CQ4=EDenc
zkDK=B9EW50iQd%IboU^aC(V~OFx}@!NpZP6Fg_^N?Mihxohkeue5Up%;B!>Nk>WJK
zr6aIx{Gn@_k?M3)+8t^ZnOQWPCnOdqjnhE!y}jXpH7H6O7Q_(vY@|wtDL1X7N1dro
zV87jV9@GnPu8Q!7@7SYj@%Jcr^x@=TlutKAv<^mF@b}AaYy8-*MDdg;O1Jr^<L@k#
zYw-6Z%AFD$MUzo4%2oKQlRV4*yl6n=!T$@Q7m16-<<YC6C89K1X3^-kh}JWr!^NoR
zxM+@;f|d;7ijHGnG!8zAApS0f^eX&S;O`dvt;gSk;BUj<EBN~mf2se8{-N<gAEqO?
z-~*onKGr6b>0I0gnPrR8c%&z5WAR7t#^Bubvz;YoMrR51Qgn_eh|U$kXd(Iv=Q_zY
zDmpqkMw}AO6ceInh)Gdg#nECK&d>>BgdKw*?RT^5+v_(SW9!%WHxSy}`?mFCxOYr(
z&NPuTMdVHqh1J#Jijr#oLjSlj#Bx>^ejA~_G*l6;4V70_hZ`rC)-GtME1g{1P?W!5
zPDs{5dGm5ZSB@(SEgaVvntj>g+^kZuT+At{t*wjrOB=!^k+5H!T2)(G-BcF#&uom8
z;S2w)%5%LIW>rlMnE3Rc`OE66%KZJekqPw~p~wWk^dYaQd}1HY!f@kw{|#QjKOj(5
zTQSjJ6?c4-C)2@%8yo!<4RuZR{^eDXO8*pp-i3`cj<NY|TPReMJ8gQEe??7A_C!BC
zp6G9^sGV3>8*ZFfQ_@^iwD258+F*WC0B@E*R6_<rjp0a6C|qAPBQvwKvZP^r&iKSQ
zX|o?(?wO3VwpU));HS><SIx>kr)uW7vU94=n3c=@Agp>+rsIJ1%uID)6ULjpIsU3~
zWoJ}flh`jDwDoAJDr)7?a7VCJc|i8|&|?-{$<js%BRBdS2Vvv&QG<Tdj7;u$)s^u^
zlJsLTf9d2|+!cxZHBVZ6^YYXrX)jTSQZULswVY40=lGD|4jHt1vC=CNM(I>bl*Y$t
zqVs<SpZ<h~rb$DVHj_0uU1}z@GNX?b7))j;CtGSmZrS*H@m<W~$JcMi*KfzyZ^zef
zmbu|rODKzK!s4+OK*zFwEP294zXkJH{vAs$7jHAp`cJRla{dR_Z}Dv$U%%11@A&%d
z`1%d=gk|;R|G%<+JM+J5ZFg2bhV;5G;R-TGA>$W?Y7Wg7#iCtwh+g4078p@ui_vZP
z905nYW22+XA)MLHVyE~<I@#aA4z+fywxmb>`=h<?&u6XEE0P~qOvj(}*sVGXlJrl!
zPBdX3+I6-h=;yvV-G=>KB+~KO&R1fcK-@V^rc-Y@@5yyGnz7NJPM1T*PyafCW9(Qu
z*-m4W^PB+U){VcE$BrJo74!+vt3fwCPA_W;ab(ZYqpuU)kDrtSUEOo^=rE+@4uM_`
zIt)D8jO!N)quFPS8tC@48*U%*=|SEC*qcBKYD=syQ*WeSzXcyMkZ!tfZu*GxGX^a8
zM8$b0oiky|Sln?*oB5z0!S3ZJpfEe#x5hDNkjuI71T@WUmXRL(7GtdPf1Ir4tHJ&X
zUm~rc)S`*M*&sRD{we+{@l9M9ROF@m?r;>OkGS1gknX=Nr64`?*3@8n_8M0(eMXCW
zetMufea7tc?Ahs=dFlSV^byd{OZRZUd;)ko>^R8I@$GmI9PfeSJ#f4Sj`zUv9ys0u
zx(D0=E_J&k)olILQ`3P;P?;+A=y4@&t7iq6j^sW4-g+^Y=n*Jw{OBC?B(C9ipp~4~
zTC{2T=U*S?C&3#W0b-lK`QG7_br*Am*zS;Zoe;;PTi)n*v}w~1G-+vO-Eh+*x8h=^
zdQH@;*m_+^Yf;+hw;X6|P6;s8{9;wte(Uz=xBY0-b-WM6#}iQcc(Io2x<7kWJyXdg
z`v3f1|Bk)ArH9mc-KuD(qHij?U(v&gx>URjSM)SRr(5D^-kdpS`!n&2@8kVbvu0#X
z^XF#gOv|30JH?;5FkI#jmP90f(v-8ti;3_^o)p=&lT={xBHQjQ>Qa9;;y~)J9vzTc
zwCGN-N&OVWh0^C+4<UFFo<M&VET=HvV?2_I8;n8lZmmm*M2<QBi1X?gI|KSo!<B(x
zb2?J#HX<b@6%QDN)00{cxZ`b7%MP)cXAsmJH=zwj&i9DpaKB5HUlV&u3vp81o5_^N
zeIF6SHJody*TIxCB_*FM(kmU#*S}ADPf8|;V>O&jxph7jPl0~QZB&Gf_d!xUE)QOE
z5H8OL*t@Cdz$+3WHTyH{J(IC}+jTes!)a6Cs_Ton;E1$r_~rWQEmBE40-LUXQrVX_
z7Tw|cn#v>6z6Qv3l*)eZIKm2pDw*C3;E&7TO177N=ilYv$_(%2WY)=*fOi|&O65w>
z`(whmxU#_eAk4VjTv_a;PrO}e#-nJh*t?R{1{jZ{Qt54?${>S0uJ<~~+F-6kyfoLi
zh8o*Jn!UdyKTkBM$D`hAQX65=dAr5Cn~rRxu^kF6-V$o(JH}pA)_VPryG}E9gS2}$
zlh>1tH&EH&{W(>#xw6r_g(^8*dDy#+D!E+Q;@wG=DaJ#<Z1<i_jZS0VI=rWl<V@pL
zwDY_eu*i+tPdwY<$q3gbI>@wpNntY;McOFx@Ig9UPuc<OUH>{4Y#&bN4OH{cNgPNg
zmE0cmDhkA<)5+YwXzoyohYe)Ra}YdtGwU6u;vy8&Z^6#+*aO|T*8^WNu7s!@3eNS9
z-k5=#ZV&n3T>tQmKD@vv3@<4;*KfJWH-V~yM{u=w)!_0nVGPYg&9Q#5&x<}VPU=OA
zj`fwkLbzg#`iN@_2G1A9Sn|lRzG(2Z!WbvZWrMF1#%Z!#?E4C*$H<hmpzkRljVbxu
zQuiv~i&R}5;%dh#-yf;^^z~eAU*%g%jeU9-SG!gY`724Y3_5qt_3bN%{G2RT8!vNx
z%Z*~-J8*>#g8S1Udy)==>pAGc9w-c?ej^8@7Viz=&H`s3brw0pOs7;3?m{gh$C#NS
z6@;7qK@diflgvz&3c^j(1-C{1GSkg_mvH}Bi^z3mrt#h*+)t8-I;&fYJi@mE2kyT1
zb8ym};@kkFsCQ{iFGdr?Q-$w`q**-%oHQr>@;hsONt$%jQ?({+rh@6NFJ#T2)*Oqf
zuNuAXZYX8R#c`4=z;j1vD5p8EjFX&<(coV8BbJm}CEV_#;IoG#h3^Gwcf~H&tk;_N
zqUt-FY~1i?mbAx7W)WuP=PcP`m9TXRP<{OGq3phS4EAZxm$c@WWIdN8EoZT$D^9YH
zj<@v^me4QZ%RVE_K@{EpQo|DZL3~rf?cM@Dw>wDqhC<!_{U5RB`&zRBRo@k4<JQMm
z(i<l^8{zA|{biPXZI!U~Zt&UqcZBZ->X|z~XHDOE%8xEoecfc^?hMFrzT+e>K<wTy
zo+S(7BzzS2&0$G>oFqi;Ja7$5+T$dpbOtspXUP_;gk$wq@U^cOQo9drV$E)?c_XT<
zxm9brh0jgCKm0Ol76;T(J)||ewPuR&O`_g?<a5@HYRxXvEXToku}aXb&p_S%%Q4`j
zIX7y}FSX`Wt%=spr;+mOLe}ionqyIAn@hANTK^{<(PNFQ*{d}#BuyHpYqjQZ;oCt+
z^yGc4DQ2r9YSx;MYt1y_TSuDP_ONEL*4&J$?+l8@r`}^pyO!_>rei&<ZJ@PXbgWMg
zz;ZUt*`YP}LxGRL4?gz_TKkmF-p*;P*{d~usIunyS`+ifsnjbSA=XUEQ%7(%X--0G
z5v@5!_(J68?l#u+Yt1rLeHC<UFFeSSK%C@vgxT{9ONy-$w*DIU?D2Vsc<S?){+%_W
zTJt$neYa99ykcO<hog>@Gzv&w9mNtcCx9C2gc-UP$L~3HF6zTp!8y;^$52Fo6c>YH
zdzKfFJ`%|V<N-tsEg<bH)$4Eo#}|;t7m)uSEg*k{P&YjGKsW9^3uDHzfZW$)SwOzs
zq!y5*WLZGcLdm&aFCec#&0Ii^id#UAwk#k|mrFxlK&oXTFCfQDzFI(@A!}*@d2SQ8
zq!*AI+PT`L7LafKf~y->4dDgkiAJZ?UOD7NI@l|W_qZNaE6V$fuejcE<B&g+{5|7D
z%rQ8Q8{`V}bVn}N+iw`Mo#eHS`CRXAk}FO+YM!^$ij$6;>v1bi@>pu|9xF~-X!50=
zyl1Al;-rNp&&_lsEHYP|cWDtF6pPFiCoMD?MaRb?msAjLT4-`xbg0ZU7o+>Nh>n^?
z9;qPQ1~`nO4q&FaP9066a?G977c3gW`@zC}CW+{DE!84(3A-E|OxyDUkYaLPs5NO)
zXSlh9-Nc%`TJuKIq$TWDt!XY{UuI2DFhC};^gvZDVLxIC{V-=tBA2j7Swg?h8I#B*
z>`2V|Y0guv5^gsOeD=^>!p>pMY^_PRifRda4NDfpN#qiCIZNuT61ILT`1<(e5_S`7
zeqU?eh^kt`{+1=}aT2+NeS;-;$4TT8_HQh?*DB$5QxMPGuDOIA2~L`Gv(`LB?aC$W
z6qam>lgK6Pe3tCAO4#~RZQWeL$^~SX)?5e$wS-;IHhSYEatZqjmiP+Qxnc~TwfkOR
zNp_q>E@9tg$$~hET*Ce@megA%9IJQ^D|-UI$|dZnyad~*HNOUsHD_o|a|t`2HT~x+
z4>M7f@vk+_CG2w63~0@Tq*;!Gxm9bT^%<zUf4PY@i?!yBT63$`G?%b1v*t#v`H<G^
z)|%!L_H)+UqBXlnlg6o6FTBhp>=<5nb!g2mwdPc<X)a+4S<`=kI`*-sswHeGOBQGe
zk6=31X7D-Y%q8q?tQpms^e@<PuWZ(u<`Q-rYi`k+KhT=5Xiako`yOjPuQi`0O<KYp
z)|%!Lc7T^6zFTYVhk{zdj$?@^Qpd&;xr9BBC4Q@ftuF$fkIh`dR<UM4Yv!Y>mar`>
ziN;Cf681ipbXX<FT*AJNV@nZ!hq;73ig@KEtSx!^2k;#-P3bUXVpC-^WeU?FlcElp
z6vdZ&loWNSq^L|yLWR<sDU{)G<eY<+@p&IEjPA=(q<>YAHl3_B?tK|G7gAAaRB*13
z-sIjnGk{|3<0)5_Fa{FXvA!AyK)sL_#x55|2OHzkhYoP2k4hhG3~~ETgwk-~Oh0?T
zIRgrZ!roXhV8FSM!yi?IE2$aaqE#ZK<vvXi@eDPb=>rB3)<89FkZEWJw7sgDS~!%d
z19UTp9K$FaN{B(Hz|Ld{)3c28MoKSEA4!e{M%<k@l2kHMk+GBBIY!`QPc_@1>R?nY
z(jiKUCP_LprhMMWnImz#Vr7uV@&3@K{=AV%`y&<-Iyw*%Df)C$Af(1lU*XWW)8~pm
zLGA$vz#$ki9tr`3j1B-%LAQe9Q#vKaKhg)$C!@H36!<eHH#Ig)R$qn*uHc_@om^2`
zIvM{IZ)p0|Ne$t$%94ou=Xodd^OksZg`K>#3ja_nK3B`il6w^B|3w#FRCI|D>N_?1
zjE%lkD_Pb|->6~J-=dK-D3^uHvnuI<O=LxVxDiEoPAYXMLIb|(qWn0mEL>Vw7H$Xu
zN7@+Vk*b<-s3u%ORji!Q4Gx`gKFPD*vrITr9IkfkjdqvkamR$Ao(rhrin#WB9`HQi
zm~g^suD81$uv2G-Bh&C~h6-tVHuiX)@mvcf$1}9^w9?*@GmI-6dB0h*PT<O>7|X+D
z$AsZ5pV}8PH5p_Q>pIW(+z+VXI^X4-dB10qqk5Pp*YmmO+Gjnjj=94;8$I0e57>Nx
z#g?-<1{_4dtf9_OjFm~OCyW!Nv1edxn$1`snXz)uMl!ZEW^C;JVBPLe#yVhZo@wl9
z_H1r4W6HB7F=G>8%;|NkbsEyQoiLYA=C~)Nx$~2lOIPNKW9Ckm<_@PQbJTBaj{B{D
za|!zGwEH~|{MLal#SKcb|35U;a{h;hn!Y#x219LQze8=L8fwGLq2^4(^C65dXW9-T
z|D(e#KNdO92@2~)Jl@Eq=MXt_Y;j$fBoKAvTpcra23dQ;7*0{G&3%h8#{<}6j)sXI
zbK2au9d#CS?A@1+kyh{Q=7QhyVAncNvYPw0qt4=;niG!5IYA$;z4!9Jxqr%_niaIc
z|AL3qf6jr9i9E|_d%^#Fv|xT#^9<IWm}ls#{{AoNg8oVNzL#3MEb7(o$QH-r4(=qr
zUU*t~c-@3OU0-Ui;CZdODH5t}s>!P@tj(*PM;~i9@|AoczFZI0RhNb8%FFRlwJ57=
zT3Q_zp~8zoa|??K1mXDKhM!$l)}WC^)eQjWgcjnnDP_2ztRmdFAPf~{b_zVF@42Vt
z<nlMlqVLz}SWSc*N+NX){LMSJ*;ukH917Q#iN;F&ll6YOA84$)J{*el=SVIbnZ|mw
z>d+p|!J*EHJ5+q0pYU+xu|P^ky}Y3+5)Rcz8bqkPx}>5}o3kIFQeWCs9$H$`h#sr1
zE4@x!A8x2?qz}~T+jJ4CDQUPa+|VdW>zhL54dL&F<^``$>H{5y^suU|c@F<fz`UI7
ze$}UmCUg<L;@4i<&M!_8{KV4kB0jr?vOAKj<`VXeJk@XwcFL>kO8Pw!vbpNI+6q7K
z==8-|wVaQfq>@|_Ds5^AmDW`^)zq?9tUv7iGu0+XFxS_~a~1>PM3^U*&s9@xBfcBQ
zyGHce0V33hlPE$o0;W$*7HKl7(FqBUN6>fs=4mGtj5S*T#)eDGv*{w%S*BCeYjj$t
z<iZ*9Tt*T6q%lFh%8_-9_GCB_9zP&a#)C>ZMnPgd6C8J;rrM^)a9OS>uPv#O69D6A
zBq&_m5WwN!b4fB!Lx6^?#k!s-%wD78$(fGhsjIJtatY>`GJ&xlZlr-$8*avthU!bo
zawI_rPz@uJ$W%$D=@#sMVAROzBCZR`og_0?Y^32d#aSbXY^M)Y&JyaF<t$-2>b@tN
zCJ6e;kJ>uKb0ubR90fuQeZZ51IWKY-mXu!CR4*qIycp-7bL=<c{F7?vE(|2nR2!bf
zb7@s6aT`i2XW`~=()6kRNfrJ{xc!<{dKOL<PiMKh6Ri$oqQYGmpG-dIJV?~(wCc&z
z*?$M&WQ3MQ=mhIa3XKi(XeU?J)r2QEu9&Ru{PYi@MC$6Q8z;xE2=a!LUE*tk)uq0Z
z9L|a*`Yf^C&-pYjVllAoSY?PS!*O9ECptQFH0!H5Bk|=`&KP}VayqbI6m#g8VyqWM
zYCSez<jCWUG0x=Uj@8eKpWDsb2epbILig1DZcf~(&u|3#=s2-pS(K3P6p@7d6tN*8
zKh=C+*V>2^F9&uw16CH7o%j+g(fhDYyt1j^qqTyZB25&hB(mc*-`kDXA0YJm%klhy
zqCGW{ok1etO2kh$-+PX?lOa0P`_S=xpSX2VB0GacS3>>}^F8W#J44O)r{np<gnvn~
zmBnQze&8w5`@T*wTpS4{(nlh+I1zt@s7%NoDWVDa`fcxcmz+Ys6>jH`j%TQvQ+y{0
zpMG4c@8;wW?&A5#MIqVr_oMM#WM9EB@Rgjs-;f_g^bZpCw)0M&6Mv(PpQZTSHhw<a
zkM$4vK^szRXt(cqydHeAFWdo?V%r)N4be9qeg=M`<N7V@XW;kz0w~Gv8i~^Ds)ooA
z*@{nTU)uhLKjQ1R_3)sAw*hdN`1)Nv&Bss2F<-x_r}=XfU%#iP`60!xSMBP^SfTjs
zHa`6;WYq2!8=rpWg!uaXJD2kFMaAz@`kMcd;_G+sG~YnVlI-X=?==5Aim%_ZL+YQm
zGZnvA+1LDw6<@z&r}^}5Hre;7x72i`{)^&g+xQPE{sJ5SS;eon@&By&?Kb`wioeCi
zABwyz`J>;OYgWgVqxi*v0CW6`f05!x6@QrG*C_r*#h<D8w`==~?^Aqwi=Eol@3!IT
z6K`FLuis?5TJis?`1-xIOvN9VBJJq6)^yzR%f+y--%+D+NZSQUU%!#2{jXO1l)M0`
z@%Sfto8tTP0#p@#-U~r*(~|#zya03jycgnO#V^haFvrh({A8fwNAm*Ak$b$<t@s@_
z{%eY_-zn4j^p-_`<66JwFqT`1jcff<gYF+auJtPndOYfJtzTf!d_Au9>kFE%$F+WW
zLG$&v&JIe??c;iZjjzXby^XKOwSFl<k4HVO+m*iN>v64LNYH#euJ!8(ny<&Te)&L;
zQ$4P?DEpeP$F+X(K=bvu?o#^paoua<>v64LG0^&YT<aGMG+&Qv{d$4s>v64LF3@~E
zuJx+~_Hpe$U!E7giW5Dq1B$Q5g&x<%if<p+8x`L^uJr?dud=Vlb%)Zok8AxfKU3-J
zajhTa>$uh9T0gkAk8AyyUi+`dwSFj1*LB+TxYm#0{mhMxYf%(nj^^ue?YHsuxDF`3
zM8(E+)W+B2y2Hl*BFVVMWh&u#|C;BA!9rZ7TZAIEfp}DwXx&1xMDxZ7ezZ2E&$@9u
z+v&SL%vJjOJ3g{YTLJU?u45OooxbbFTJVQpJrh;yVTUv$Rxw{yEaYAA{rGy$zRp~q
zME^nXebBEiF1A<^f<D!ve<aerH8a2Oy8U1h{hdkp?|@J3+Wq`Ei9Wp)=C?b8dO9Yk
z!Hx{E*LJ@!iuiP0Q+$L0Zxg_${`4t+Sn>Je3NcbVZ0m;)*q^@lFK5G!5Bm0go2%^W
zT(f@D;sW+(q|mQ5dsMrNSzlEw<hmsMXcGRNWFHUR>uvsTWc@*XUY6da`1(<?{ycCh
z^Ap_Pl{Q2gBTePyNUeuL=g(OfDk{8WQ79zvFgjdO)fmAu=}1ke6zREeBQ(nDLKW3@
zOG~OlWyn`IhDw^6MQL44eRVhzF3XxeWf~HXiIk85s;vr@G&Gc~K-w$PutJnKAiWkU
zYpSVP0f?m*f@UO6HSt4t$_SXrDNCxOzl3Vy<cLf`C|Td!M=ZJDSEdr73A3EBe2P71
z60>NR#O&E6F>AK8Wh}MR*NbDx%%qI%$bd`YNu0$vA4y``vrA&u`X;SnsJ^oPaPd77
zpK4XPxxVS9I4^DO#g5vHD~r`wlq8WVUz13cw|%5$`b~91a)o5}O$*7IIA*#s)+v2j
zH#669!%cUK`BWrXE;OcKdt%VX0*)^3;X(WpBwMCGE|nUeMz%d|i<>*_X~0lu?!wvg
z3ql1K=3~l}^Peuq%|c}&lz+vAv*#DiftE$W-31nM)uDo*vKGu=C_?j!F3Ou-6uM~c
z+)D};g%-`uD=MHC@ZwKtsI(DJ!C*!HoOB>Cuc$C@PAE4kH*1=xZ;CX=b3);=l1Pat
z#~j=kwuz)Y_5x2ws%q_GLdr=}l-J`ou_NVnjf$GOTB*T3P}W!%sw}B3Q;$CRt)>t?
z53%}A9f11M#ztkE)2VUK_R8z(!!~ak6FE@M4-o85Et)?^os(nch3yKt_QbKsYFtr+
zJUnQmLDEWHLWhJK>O~fQUOb#NJFjq3q@+UCDr%dumNr#YmrbfF6IoQNENQG1S!F9~
zVNX&#vSG<GJld?PtBtFKAZrL$mk>ae>Z>Cni~BAsLJxYfI0mvB>iGO-g)7xnu(AwT
zU6TlTIg|)pzP1!<uwGJARf?wTU=X`3Zbe$e2@+YjI@jQe3)S$_rV4;dYVm|xSF38v
z>vXwf>C%SqGF_{#stxNhJ)HXQ*(gs)YkIxjo#6<eCXi=m!oLqDOL9-T*6mbO@MfTi
zU*rg&CXkP3(q}EH*N0LnL=Fm8e8dr85q$(s+gM4=y&azq$zl99h4z1gBfz>FZ2n_;
z$(vpes;amU1-!~?`oG-~K#hL4g9%=FloZP~?kA1c_kWjx@5G;Ozrz_oP2hO}6Hy_F
zxwrS<5=iK`HZ)#8PoOWhX&Wwy`THVTPt)rlr{C_-^*~C15dnqwa}93+gHqetf5jG*
z$0b#bFIM<sh1bVv??267t?+rup#J@lW`)<kS3-E)b(!sJ{O#b8U*sQc`gupCYEb8C
zq*VH<%S7AoXT|I1BJB!KKWbs!bY4KyJ0Y~<1Fit82b4p3XIjy8FA~4~7*#7?|Gv!X
zSyE5upEOE!i>``|C=p)wzrK&^Q21AL04PL2QB593!HU<<ZEjs8HS)EhqW1Q;+VJ}M
zPM5+@CF7RO9zPwBrQ=V9yZIc*M}dvauCMEwz5*R&|4qF9y`2%?5dSu?<f3k0KOgZQ
z0}lvq?_f`-TI2Qer%Z+KQpd03Q~RysU_Y?d_VshBBOx|_%;P_3!<)~uiY2~M5_7NH
z*Ypr1*7o&%er2(Q*w42*9Mj&HD3L9F{QCJ=b+J^*l*HWo&5|q}1tFW+HonHw=O)%o
zx34M9uexm2yQf&z+O15K?Ybu>!H+MIz<stKR<h$yO@dEdF7fy1fvNnk<8zYW?_VJS
zbM%Qyf}f@E_WpbCW(gRO1h4%dYIBi+y)-e>MuQ96Dfnx}pEjrGUz(rvxku65dN;`8
b`#SKIM7OIIk?~82f9(OO5wrnpRq?+8{svb4

literal 0
HcmV?d00001

diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_avx2/main.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_cnProc/main.c
similarity index 79%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_avx2/main.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_cnProc/main.c
index 590541a9e8..959051f92c 100644
--- a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_avx2/main.c
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_cnProc/main.c
@@ -1,11 +1,9 @@
 #include <stdio.h>
-#include <immintrin.h>
-#include "../../nrLDPC_types.h"
-#include "../../nrLDPC_init.h"
-#include "../../nrLDPC_bnProc.h"
+#include <stdint.h>
 #define NB_Z  51
 void nrLDPC_cnProc_BG1_generator_AVX2(uint16_t,int);
 void nrLDPC_cnProc_BG2_generator_AVX2(uint16_t,int);
+
 int main()
 {
  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};
@@ -15,6 +13,8 @@ int main()
 
 	  nrLDPC_cnProc_BG1_generator_AVX2(Z[i],0);
 	  nrLDPC_cnProc_BG2_generator_AVX2(Z[i],0);
+       
+
 
 }
   return(0);
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_avx512/Makefile b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_cnProc_avx512/Makefile
similarity index 100%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_avx512/Makefile
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_cnProc_avx512/Makefile
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_cnProc_avx512/cnProc_gen_BG1_avx512.2 b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_cnProc_avx512/cnProc_gen_BG1_avx512.2
new file mode 100644
index 0000000000..da72d4a934
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_cnProc_avx512/cnProc_gen_BG1_avx512.2
@@ -0,0 +1,583 @@
+
+#include <stdio.h>
+#include <stdint.h>
+#include "../../nrLDPCdecoder_defs.h"
+
+void nrLDPC_cnProc_BG1_generator_AVX512(uint16_t Z,int R)
+{
+  const char *ratestr[3]={"13","23","89"};
+
+  if (R<0 || R>2) {printf("Illegal R %d\n",R); abort();}
+
+
+ // 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 \n");abort();}
+
+  fprintf(fd,"#include <stdint.h>\n");
+  fprintf(fd,"#include <immintrin.h>\n");
+
+
+  fprintf(fd,   "#define conditional_negate(a,b,z) _mm512_mask_sub_epi8(a,_mm512_movepi8_mask(b),z,a)\n");
+
+
+  fprintf(fd,"void nrLDPC_cnProc_BG1_Z%d_%s_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {\n",Z,ratestr[R]);
+
+  const uint8_t*  lut_numCnInCnGroups;
+  const uint32_t* lut_startAddrCnGroups = lut_startAddrCnGroups_BG1;
+
+  if (R==0)      lut_numCnInCnGroups = lut_numCnInCnGroups_BG1_R13;
+  else if (R==1) lut_numCnInCnGroups = lut_numCnInCnGroups_BG1_R23;
+  else if (R==2) lut_numCnInCnGroups = lut_numCnInCnGroups_BG1_R89;
+  else { printf("aborting, illegal R %d\n",R); fclose(fd);abort();}
+
+  
+  uint32_t M;
+  uint32_t j;
+  uint32_t k;
+  // Offset to each bit within a group in terms of 64  Byte
+  uint32_t bitOffsetInGroup;
+
+
+
+  // =====================================================================
+  // Process group with 3 BNs
+  fprintf(fd,"//Process group with 3 BNs\n");
+  // LUT with offsets for bits that need to be processed
+  // 1. bit proc requires LLRs of 2. and 3. bit, 2.bits of 1. and 3. etc.
+  // Offsets are in units of bitOffsetInGroup (1*384/32)12
+     // Offsets are in units of bitOffsetInGroup (1*384/32)12
+
+  const uint8_t lut_idxCnProcG3[3][2] = {{12,24}, {0,24}, {0,12}};
+
+
+  fprintf(fd,"                __m512i zmm0, min, sgn,zeros,maxLLR;\n");
+  fprintf(fd,"                zeros  = _mm512_setzero_si512();\n");
+  fprintf(fd,"                maxLLR = _mm512_set1_epi8((char)127);\n");
+
+  if (lut_numCnInCnGroups[0] > 0)
+    {
+      // Number of groups of 64  CNs for parallel processing
+      // Ceil for values not divisible by 64
+      M = (lut_numCnInCnGroups[0]*Z + 63)>>6;
+
+      // Set the offset to each bit within a group in terms of 64  Byte
+      bitOffsetInGroup = (lut_numCnInCnGroups_BG1_R13[0]*NR_LDPC_ZMAX)>>6;
+
+     // Loop over every BN
+
+      for (j=0; j<3; j++)
+        {
+
+          fprintf(fd,"            for (int i=0;i<%d;i+=2) {\n",M);
+          // Abs and sign of 64  CNs (first BN)
+          //                zmm0 = p_cnProcBuf[lut_idxCnProcG3[j][0] + i];
+          fprintf(fd,"                sgn = ((__m512i*)cnProcBuf)[%d+i];\n",(lut_startAddrCnGroups[0]>>6)+lut_idxCnProcG3[j][0]/2);
+          //                sgn  = _mm512_sign_epi8(ones, zmm0);
+          //                min  = _mm512_abs_epi8(zmm0);
+          fprintf(fd,"                min  = _mm512_abs_epi8(sgn);\n");
+
+          // 32 CNs of second BN
+          //                zmm0 = p_cnProcBuf[lut_idxCnProcG3[j][1] + i];
+          fprintf(fd,"                zmm0 = ((__m512i*)cnProcBuf)[%d+i];\n",(lut_startAddrCnGroups[0]>>6)+lut_idxCnProcG3[j][1]/2);
+
+          //                min  = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0));
+          fprintf(fd,"                min  = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0));\n");
+
+          //                sgn  = _mm512_sign_epi8(sgn, zmm0);
+          fprintf(fd,"                sgn  = _mm512_xor_si512(sgn, zmm0);\n");
+
+          // Store result
+          //                min = _mm512_min_epu8(min, maxLLR); // 128 in epi8 is -127
+          fprintf(fd,"                min = _mm512_min_epu8(min, maxLLR);\n");
+      
+          fprintf(fd,"                ((__m512i*)cnProcBufRes)[%d+i] = conditional_negate(min, sgn,zeros);\n",(lut_startAddrCnGroups[0]>>6)+(j*bitOffsetInGroup));
+
+          // Abs and sign of 64  CNs (first BN)
+          //                zmm0 = p_cnProcBuf[lut_idxCnProcG3[j][0] + i];
+          fprintf(fd,"                sgn = ((__m512i*)cnProcBuf)[%d+i];\n",(lut_startAddrCnGroups[0]>>6)+(lut_idxCnProcG3[j][0]/2)+1);
+ 
+          fprintf(fd,"                min  = _mm512_abs_epi8(sgn);\n");
+
+          // 32 CNs of second BN
+          //                zmm0 = p_cnProcBuf[lut_idxCnProcG3[j][1] + i];
+          fprintf(fd,"                zmm0 = ((__m512i*)cnProcBuf)[%d+i];\n",(lut_startAddrCnGroups[0]>>6)+(lut_idxCnProcG3[j][1]/2)+1);
+
+          //                min  = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0));
+          fprintf(fd,"                min  = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0));\n");
+
+          //                sgn  = _mm512_sign_epi8(sgn, zmm0);
+          fprintf(fd,"                sgn  = _mm512_xor_si512(sgn, zmm0);\n");
+
+          // Store result
+          //                min = _mm512_min_epu8(min, maxLLR); // 128 in epi8 is -127
+          fprintf(fd,"                min = _mm512_min_epu8(min, maxLLR);\n");
+
+          fprintf(fd,"                ((__m512i*)cnProcBufRes)[%d+i] = conditional_negate(min, sgn,zeros);\n",(lut_startAddrCnGroups[0]>>6)+(j*bitOffsetInGroup)+1);
+
+          fprintf(fd,"            }\n");
+        }
+    }
+
+  // =====================================================================
+  // Process group with 4 BNs
+  fprintf(fd,"//Process group with 4 BNs\n");
+    // Offset is 5*384/32 = 30
+  const uint8_t lut_idxCnProcG4[4][3] = {{60,120,180}, {0,120,180}, {0,60,180}, {0,60,120}};
+
+  if (lut_numCnInCnGroups[1] > 0)
+    {
+      // Number of groups of 64  CNs for parallel processing
+      // Ceil for values not divisible by 64
+      M = (lut_numCnInCnGroups[1]*Z + 63)>>6;
+
+      // Set the offset to each bit within a group in terms of 64  Byte
+      bitOffsetInGroup = (lut_numCnInCnGroups_BG1_R13[1]*NR_LDPC_ZMAX)>>6;     
+
+      // Loop over every BN
+      for (j=0; j<4; j++)
+        {
+        // Loop over CNs
+          //      for (i=0; i<M; i++,iprime++)
+          //            {
+          fprintf(fd,"            for (int i=0;i<%d;i++) {\n",M);
+          // Abs and sign of 64  CNs (first BN)
+          //                zmm0 = p_cnProcBuf[lut_idxCnProcG3[j][0] + i];
+          fprintf(fd,"                sgn = ((__m512i*)cnProcBuf)[%d+i];\n",(lut_startAddrCnGroups[1]>>6)+lut_idxCnProcG4[j][0]/2);
+          //                sgn  = _mm512_sign_epi8(ones, zmm0);
+          //                min  = _mm512_abs_epi8(zmm0);
+          fprintf(fd,"                min  = _mm512_abs_epi8(sgn);\n");
+
+
+          // Loop over BNs
+          for (k=1; k<3; k++)
+            {
+              fprintf(fd,"                zmm0 = ((__m512i*)cnProcBuf)[%d+i];\n",(lut_startAddrCnGroups[1]>>6)+lut_idxCnProcG4[j][k]/2);
+
+              //                min  = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0));
+              fprintf(fd,"                min  = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0));\n");
+
+              //                sgn  = _mm512_sign_epi8(sgn, zmm0);
+              fprintf(fd,"                sgn  = _mm512_xor_si512(sgn, zmm0);\n");
+            }
+
+          // Store result
+          //                min = _mm512_min_epu8(min, maxLLR); // 128 in epi8 is -127
+          fprintf(fd,"                min = _mm512_min_epu8(min, maxLLR);\n");
+          //                *p_cnProcBufResBit = _mm512_sign_epi8(min, sgn);
+              //                p_cnProcBufResBit++;
+          fprintf(fd,"                ((__m512i*)cnProcBufRes)[%d+i] = conditional_negate(min, sgn,zeros);\n",(lut_startAddrCnGroups[1]>>6)+(j*bitOffsetInGroup));
+          fprintf(fd,"            }\n");
+        }
+    }
+
+
+  // =====================================================================
+  // Process group with 5 BNs
+  fprintf(fd,"//Process group with 5 BNs\n");
+  // Offset is 18*384/32 = 216
+  const uint16_t lut_idxCnProcG5[5][4] = {{216,432,648,864}, {0,432,648,864},
+                                          {0,216,648,864}, {0,216,432,864}, {0,216,432,648}};
+
+
+  if (lut_numCnInCnGroups[2] > 0)
+    {
+      // Number of groups of 64  CNs for parallel processing
+      // Ceil for values not divisible by 64
+      M = (lut_numCnInCnGroups[2]*Z + 63)>>6;
+
+      // Set the offset to each bit within a group in terms of 64  Byte
+      bitOffsetInGroup = (lut_numCnInCnGroups_BG1_R13[2]*NR_LDPC_ZMAX)>>6;     
+
+      // Loop over every BN
+
+      for (j=0; j<5; j++)
+        {
+
+          fprintf(fd,"            for (int i=0;i<%d;i++) {\n",M);
+          // Abs and sign of 64  CNs (first BN)
+          //                zmm0 = p_cnProcBuf[lut_idxCnProcG3[j][0] + i];
+          fprintf(fd,"                sgn = ((__m512i*)cnProcBuf)[%d+i];\n",(lut_startAddrCnGroups[2]>>6)+lut_idxCnProcG5[j][0]/2);
+          //                sgn  = _mm512_sign_epi8(ones, zmm0);
+          //                min  = _mm512_abs_epi8(zmm0);
+          fprintf(fd,"                min  = _mm512_abs_epi8(sgn);\n");
+
+
+          // Loop over BNs
+          for (k=1; k<4; k++)
+            {
+              fprintf(fd,"                zmm0 = ((__m512i*)cnProcBuf)[%d+i];\n",(lut_startAddrCnGroups[2]>>6)+lut_idxCnProcG5[j][k]/2);
+
+              //                min  = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0));
+              fprintf(fd,"                min  = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0));\n");
+
+              //                sgn  = _mm512_sign_epi8(sgn, zmm0);
+              fprintf(fd,"                sgn  = _mm512_xor_si512(sgn, zmm0);\n");
+            }
+
+          // Store result
+          //                min = _mm512_min_epu8(min, maxLLR); // 128 in epi8 is -127
+          fprintf(fd,"                min = _mm512_min_epu8(min, maxLLR);\n");
+
+          fprintf(fd,"                ((__m512i*)cnProcBufRes)[%d+i] = conditional_negate(min, sgn,zeros);\n",(lut_startAddrCnGroups[2]>>6)+(j*bitOffsetInGroup));
+          fprintf(fd,"           }\n");
+        }
+    }
+
+  // =====================================================================
+  // Process group with 6 BNs
+  fprintf(fd,"//Process group with 6 BNs\n");
+    // Offset is 8*384/32 = 48
+  const uint16_t lut_idxCnProcG6[6][5] = {{96,192,288,384,480}, {0,192,288,384,480},
+                                          {0,96,288,384,480}, {0,96,192,384,480},
+                                          {0,96,192,288,480}, {0,96,192,288,384}};
+
+
+  if (lut_numCnInCnGroups[3] > 0)
+    {
+      // Number of groups of 64  CNs for parallel processing
+      // Ceil for values not divisible by 64
+      M = (lut_numCnInCnGroups[3]*Z + 63)>>6;
+
+      // Set the offset to each bit within a group in terms of 64  Byte
+      bitOffsetInGroup = (lut_numCnInCnGroups_BG1_R13[3]*NR_LDPC_ZMAX)>>6;     
+
+      // Loop over every BN
+
+      for (j=0; j<6; j++)
+        {
+
+          fprintf(fd,"            for (int i=0;i<%d;i++) {\n",M);
+          // Abs and sign of 64  CNs (first BN)
+          //                zmm0 = p_cnProcBuf[lut_idxCnProcG3[j][0] + i];
+          fprintf(fd,"                sgn = ((__m512i*)cnProcBuf)[%d+i];\n",(lut_startAddrCnGroups[3]>>6)+lut_idxCnProcG6[j][0]/2);
+          //                sgn  = _mm512_sign_epi8(ones, zmm0);
+          //                min  = _mm512_abs_epi8(zmm0);
+          fprintf(fd,"                min  = _mm512_abs_epi8(sgn);\n");
+
+
+          // Loop over BNs
+          for (k=1; k<5; k++)
+            {
+              fprintf(fd,"                zmm0 = ((__m512i*)cnProcBuf)[%d+i];\n",(lut_startAddrCnGroups[3]>>6)+lut_idxCnProcG6[j][k]/2);
+
+              //                min  = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0));
+              fprintf(fd,"                min  = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0));\n");
+
+              //                sgn  = _mm512_sign_epi8(sgn, zmm0);
+              fprintf(fd,"                sgn  = _mm512_xor_si512(sgn, zmm0);\n");
+            }
+
+          // Store result
+          //                min = _mm512_min_epu8(min, maxLLR); // 128 in epi8 is -127
+          fprintf(fd,"                min = _mm512_min_epu8(min, maxLLR);\n");
+
+          fprintf(fd,"                ((__m512i*)cnProcBufRes)[%d+i] = conditional_negate(min, sgn,zeros);\n",(lut_startAddrCnGroups[3]>>6)+(j*bitOffsetInGroup));
+          fprintf(fd,"            }\n");
+        }
+    }
+
+
+  // =====================================================================
+  // Process group with 7 BNs
+  fprintf(fd,"//Process group with 7 BNs\n");
+    // Offset is 5*384/32 = 30
+  const uint16_t lut_idxCnProcG7[7][6] = {{60,120,180,240,300,360}, {0,120,180,240,300,360},
+                                          {0,60,180,240,300,360},   {0,60,120,240,300,360},
+                                          {0,60,120,180,300,360},   {0,60,120,180,240,360},
+                                          {0,60,120,180,240,300}};
+
+
+  if (lut_numCnInCnGroups[4] > 0)
+    {
+      // Number of groups of 64  CNs for parallel processing
+      // Ceil for values not divisible by 64
+      M = (lut_numCnInCnGroups[4]*Z + 63)>>6;
+
+      // Set the offset to each bit within a group in terms of 64  Byte
+      bitOffsetInGroup = (lut_numCnInCnGroups_BG1_R13[4]*NR_LDPC_ZMAX)>>6;     
+
+      // Loop over every BN
+
+      for (j=0; j<7; j++)
+        {
+          // Loop over CNs
+          //      for (i=0; i<M; i++,iprime++)
+          //            {
+          fprintf(fd,"            for (int i=0;i<%d;i++) {\n",M);
+          // Abs and sign of 64  CNs (first BN)
+          //                zmm0 = p_cnProcBuf[lut_idxCnProcG3[j][0] + i];
+          fprintf(fd,"                sgn= ((__m512i*)cnProcBuf)[%d+i];\n",(lut_startAddrCnGroups[4]>>6)+lut_idxCnProcG7[j][0]/2);
+          //                sgn  = _mm512_sign_epi816(ones, zmm0);
+          //                min  = _mm512_abs_epi8(zmm0);
+          fprintf(fd,"                min  = _mm512_abs_epi8(sgn);\n");
+
+
+          // Loop over BNs
+          for (k=1; k<6; k++)
+            {
+              fprintf(fd,"                zmm0 = ((__m512i*)cnProcBuf)[%d+i];\n",(lut_startAddrCnGroups[4]>>6)+lut_idxCnProcG7[j][k]/2);
+
+              //                min  = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0));
+              fprintf(fd,"                min  = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0));\n");
+
+              //                sgn  = _mm512_sign_epi8(sgn, zmm0);
+              fprintf(fd,"                sgn  = _mm512_xor_si512(sgn, zmm0);\n");
+            }
+
+          // Store result
+          //                min = _mm512_min_epu8(min, maxLLR); // 128 in epi8 is -127
+          fprintf(fd,"                min = _mm512_min_epu8(min, maxLLR);\n");
+
+          fprintf(fd,"                ((__m512i*)cnProcBufRes)[%d+i] = conditional_negate(min, sgn,zeros);\n",(lut_startAddrCnGroups[4]>>6)+(j*bitOffsetInGroup));
+          fprintf(fd,"            }\n");
+        }
+    }
+
+
+  // =====================================================================
+  // Process group with 8 BNs
+  fprintf(fd,"//Process group with 8 BNs\n");
+    // Offset is 2*384/32 = 12
+  const uint8_t lut_idxCnProcG8[8][7] = {{24,48,72,96,112,144,168}, {0,48,72,96,112,144,168},
+                                         {0,24,72,96,112,144,168}, {0,24,48,96,112,144,168},
+                                         {0,24,48,72,112,144,168}, {0,24,48,72,96,144,168},
+                                         {0,24,48,72,96,112,168},  {0,24,48,72,96,112,144}};
+
+
+
+  if (lut_numCnInCnGroups[5] > 0)
+    {
+      // Number of groups of 64  CNs for parallel processing
+      // Ceil for values not divisible by 64
+      M = (lut_numCnInCnGroups[5]*Z + 63)>>6;
+
+      // Set the offset to each bit within a group in terms of 64  Byte
+      bitOffsetInGroup = (lut_numCnInCnGroups_BG1_R13[5]*NR_LDPC_ZMAX)>>6;     
+
+      // Loop over every BN
+
+      for (j=0; j<8; j++)
+        {
+          // Loop over CNs
+          //      for (i=0; i<M; i++,iprime++)
+          //            {
+          fprintf(fd,"            for (int i=0;i<%d;i++) {\n",M);
+          // Abs and sign of 64  CNs (first BN)
+          //                zmm0 = p_cnProcBuf[lut_idxCnProcG3[j][0] + i];
+          fprintf(fd,"                sgn = ((__m512i*)cnProcBuf)[%d+i];\n",(lut_startAddrCnGroups[5]>>6)+lut_idxCnProcG8[j][0]/2);
+          //                sgn  = _mm512_sign_epi8(ones, zmm0);
+          //                min  = _mm512_abs_epi8(zmm0);
+          fprintf(fd,"                min  = _mm512_abs_epi8(sgn);\n");
+
+
+          // Loop over BNs
+          for (k=1; k<7; k++)
+            {
+              fprintf(fd,"                zmm0 = ((__m512i*)cnProcBuf)[%d+i];\n",(lut_startAddrCnGroups[5]>>6)+lut_idxCnProcG8[j][k]/2);
+
+              //                min  = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0));
+              fprintf(fd,"                min  = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0));\n");
+
+              //                sgn  = _mm512_sign_epi8(sgn, zmm0);
+              fprintf(fd,"                sgn  = _mm512_xor_si512(sgn, zmm0);\n");
+            }
+
+          // Store result
+          //                min = _mm512_min_epu8(min, maxLLR); // 128 in epi8 is -127
+          fprintf(fd,"                min = _mm512_min_epu8(min, maxLLR);\n");
+
+          fprintf(fd,"                ((__m512i*)cnProcBufRes)[%d+i] = conditional_negate(min, sgn,zeros);\n",(lut_startAddrCnGroups[5]>>6)+(j*bitOffsetInGroup));
+          fprintf(fd,"              }\n");
+        }
+    }
+
+  // =====================================================================
+  // Process group with 9 BNs
+  fprintf(fd,"//Process group with 9 BNs\n");
+    // Offset is 2*384/32 = 12
+  const uint8_t lut_idxCnProcG9[9][8] = {{24,48,72,96,120,144,168,192}, {0,48,72,96,120,144,168,192},
+                                         {0,24,72,96,120,144,168,192}, {0,24,48,96,120,144,168,192},
+                                         {0,24,48,72,120,144,168,192}, {0,24,48,72,96,144,168,192},
+                                         {0,24,48,72,96,120,168,192}, {0,24,48,72,96,120,144,192},
+                                         {0,24,48,72,96,120,144,168}};
+
+
+
+
+  if (lut_numCnInCnGroups[6] > 0)
+    {
+      // Number of groups of 64  CNs for parallel processing
+      // Ceil for values not divisible by 64
+      M = (lut_numCnInCnGroups[6]*Z + 63)>>6;
+
+      // Set the offset to each bit within a group in terms of 64  Byte
+      bitOffsetInGroup = (lut_numCnInCnGroups_BG1_R13[6]*NR_LDPC_ZMAX)>>6;
+
+      // Set pointers to start of group 
+      // Loop over every BN
+
+      for (j=0; j<9; j++)
+        {
+          // Loop over CNs
+          //      for (i=0; i<M; i++,iprime++)
+          //            {
+          fprintf(fd,"            for (int i=0;i<%d;i++) {\n",M);
+          // Abs and sign of 64  CNs (first BN)
+          //                zmm0 = p_cnProcBuf[lut_idxCnProcG3[j][0] + i];
+          fprintf(fd,"                sgn = ((__m512i*)cnProcBuf)[%d+i];\n",(lut_startAddrCnGroups[6]>>6)+lut_idxCnProcG9[j][0]/2);
+          //                sgn  = _mm512_sign_epi8(ones, zmm0);
+          //                min  = _mm512_abs_epi8(zmm0);
+          fprintf(fd,"                min  = _mm512_abs_epi8(sgn);\n");
+
+
+          // Loop over BNs
+          for (k=1; k<8; k++)
+            {
+              fprintf(fd,"                zmm0 = ((__m512i*)cnProcBuf)[%d+i];\n",(lut_startAddrCnGroups[6]>>6)+lut_idxCnProcG9[j][k]/2);
+
+              //                min  = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0));
+              fprintf(fd,"                min  = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0));\n");
+
+              //                sgn  = _mm512_sign_epi8(sgn, zmm0);
+              fprintf(fd,"                sgn  = _mm512_xor_si512(sgn, zmm0);\n");
+            }
+
+          // Store result
+          //                min = _mm512_min_epu8(min, maxLLR); // 128 in epi8 is -127
+          fprintf(fd,"                min = _mm512_min_epu8(min, maxLLR);\n");
+
+          fprintf(fd,"                ((__m512i*)cnProcBufRes)[%d+i] = conditional_negate(min, sgn, zeros);\n",(lut_startAddrCnGroups[6]>>6)+(j*bitOffsetInGroup));
+          fprintf(fd,"            }\n");
+        }
+    }
+
+  // =====================================================================
+  // Process group with 10 BNs
+  fprintf(fd,"//Process group with 10 BNs\n");
+        // Offset is 1*384/32 = 6
+  const uint8_t lut_idxCnProcG10[10][9] = {{12,24,36,48,60,72,84,96,108}, {0,24,36,48,60,72,84,96,108},
+                                           {0,12,36,48,60,72,84,96,108}, {0,12,24,48,60,72,84,96,108},
+                                           {0,12,24,36,60,72,84,96,108}, {0,12,24,36,48,72,84,96,108},
+                                           {0,12,24,36,48,60,84,96,108}, {0,12,24,36,48,60,72,96,108},
+                                           {0,12,24,36,48,60,72,84,108}, {0,12,24,36,48,60,72,84,96}};
+
+  if (lut_numCnInCnGroups[7] > 0)
+    {
+      // Number of groups of 64  CNs for parallel processing
+      // Ceil for values not divisible by 64
+      M = (lut_numCnInCnGroups[7]*Z + 63)>>6;
+
+      // Set the offset to each bit within a group in terms of 64  Byte
+      bitOffsetInGroup = (lut_numCnInCnGroups_BG1_R13[7]*NR_LDPC_ZMAX)>>6;
+     
+    
+      // Loop over every BN
+
+      for (j=0; j<10; j++)
+        {
+          // Loop over CNs
+          //      for (i=0; i<M; i++,iprime++)
+          //            {
+          fprintf(fd,"            for (int i=0;i<%d;i++) {\n",M);
+          // Abs and sign of 64  CNs (first BN)
+          //                zmm0 = p_cnProcBuf[lut_idxCnProcG3[j][0] + i];
+          fprintf(fd,"                sgn = ((__m512i*)cnProcBuf)[%d+i];\n",(lut_startAddrCnGroups[7]>>6)+lut_idxCnProcG10[j][0]/2);
+          //                sgn  = _mm512_sign_epi8(ones, zmm0);
+          //                min  = _mm512_abs_epi8(zmm0);
+          fprintf(fd,"                min  = _mm512_abs_epi8(sgn);\n");
+
+
+          // Loop over BNs
+          for (k=1; k<9; k++)
+            {
+              fprintf(fd,"                zmm0 = ((__m512i*)cnProcBuf)[%d+i];\n",(lut_startAddrCnGroups[7]>>6)+lut_idxCnProcG10[j][k]/2);
+
+              //                min  = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0));
+              fprintf(fd,"                min  = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0));\n");
+
+              //                sgn  = _mm512_sign_epi8(sgn, zmm0);
+              fprintf(fd,"                sgn  = _mm512_xor_si512(sgn, zmm0);\n");
+            }
+
+          // Store result
+          //                min = _mm512_min_epu8(min, maxLLR); // 128 in epi8 is -127
+          fprintf(fd,"                min = _mm512_min_epu8(min, maxLLR);\n");
+
+          fprintf(fd,"                ((__m512i*)cnProcBufRes)[%d+i] = conditional_negate(min,sgn,zeros);\n",(lut_startAddrCnGroups[7]>>6)+(j*bitOffsetInGroup));
+          fprintf(fd,"            }\n");
+        }
+    }
+
+
+  // =====================================================================
+  // Process group with 19 BNs
+  fprintf(fd,"//Process group with 19 BNs\n");
+  // Offset is 4*384/32 = 24
+  const uint16_t lut_idxCnProcG19[19][18] = {{48,96,144,192,240,288,336,384,432,480,528,576,624,672,720,768,816,864}, {0,96,144,192,240,288,336,384,432,480,528,576,624,672,720,768,816,864},
+                                             {0,48,144,192,240,288,336,384,432,480,528,576,624,672,720,768,816,864}, {0,48,96,192,240,288,336,384,432,480,528,576,624,672,720,768,816,864},
+                                             {0,48,96,144,240,288,336,384,432,480,528,576,624,672,720,768,816,864}, {0,48,96,144,192,288,336,384,432,480,528,576,624,672,720,768,816,864},
+                                             {0,48,96,144,192,240,336,384,432,480,528,576,624,672,720,768,816,864}, {0,48,96,144,192,240,288,384,432,480,528,576,624,672,720,768,816,864},
+                                             {0,48,96,144,192,240,288,336,432,480,528,576,624,672,720,768,816,864}, {0,48,96,144,192,240,288,336,384,480,528,576,624,672,720,768,816,864},
+                                             {0,48,96,144,192,240,288,336,384,432,528,576,624,672,720,768,816,864}, {0,48,96,144,192,240,288,336,384,432,480,576,624,672,720,768,816,864},
+                                             {0,48,96,144,192,240,288,336,384,432,480,528,624,672,720,768,816,864}, {0,48,96,144,192,240,288,336,384,432,480,528,576,672,720,768,816,864},
+                                             {0,48,96,144,192,240,288,336,384,432,480,528,576,624,720,768,816,864}, {0,48,96,144,192,240,288,336,384,432,480,528,576,624,672,768,816,864},
+                                             {0,48,96,144,192,240,288,336,384,432,480,528,576,624,672,720,816,864}, {0,48,96,144,192,240,288,336,384,432,480,528,576,624,672,720,768,864},
+                                             {0,48,96,144,192,240,288,336,384,432,480,528,576,624,672,720,768,816}};
+
+
+  if (lut_numCnInCnGroups[8] > 0)
+    {
+      // Number of groups of 64  CNs for parallel processing
+      // Ceil for values not divisible by 64
+      M = (lut_numCnInCnGroups[8]*Z + 63)>>6;
+
+      // Set the offset to each bit within a group in terms of 64  Byte
+      bitOffsetInGroup = (lut_numCnInCnGroups_BG1_R13[8]*NR_LDPC_ZMAX)>>6;
+    
+      // Loop over every BN
+
+      for (j=0; j<19; j++)
+        {
+          // Loop over CNs
+          //      for (i=0; i<M; i++,iprime++)
+          //            {
+          fprintf(fd,"            for (int i=0;i<%d;i++) {\n",M);
+          // Abs and sign of 64  CNs (first BN)
+          //                zmm0 = p_cnProcBuf[lut_idxCnProcG3[j][0] + i];
+          fprintf(fd,"                sgn = ((__m512i*)cnProcBuf)[%d+i];\n",(lut_startAddrCnGroups[8]>>6)+lut_idxCnProcG19[j][0]/2);
+          //                sgn  = _mm512_sign_epi8(ones, zmm0);
+          //                min  = _mm512_abs_epi8(zmm0);
+          fprintf(fd,"                min  = _mm512_abs_epi8(sgn);\n");
+
+
+          // Loop over BNs
+          for (k=1; k<18; k++)
+            {
+              fprintf(fd,"                zmm0 = ((__m512i*)cnProcBuf)[%d+i];\n",(lut_startAddrCnGroups[8]>>6)+lut_idxCnProcG19[j][k]/2);
+
+              //                min  = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0));
+              fprintf(fd,"                min  = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0));\n");
+
+              //                sgn  = _mm512_sign_epi8(sgn, zmm0);
+              fprintf(fd,"                sgn  = _mm512_xor_si512(sgn, zmm0);\n");
+            }
+
+          // Store result
+          //                min = _mm512_min_epu8(min, maxLLR); // 128 in epi8 is -127
+          fprintf(fd,"                min = _mm512_min_epu8(min, maxLLR);\n");
+
+          fprintf(fd,"                ((__m512i*)cnProcBufRes)[%d+i] = conditional_negate(min, sgn,zeros);\n",(lut_startAddrCnGroups[8]>>6)+(j*bitOffsetInGroup));
+          fprintf(fd,"            }\n");
+        }
+    }
+
+  fprintf(fd,"}\n");
+  fclose(fd);
+}//end of the function  nrLDPC_cnProc_BG1
+
+
+
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_avx512/cnProc_gen_BG1_avx512.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_cnProc_avx512/cnProc_gen_BG1_avx512.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_avx512/cnProc_gen_BG1_avx512.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_cnProc_avx512/cnProc_gen_BG1_avx512.c
index f013c9b630..fd691a66fa 100644
--- a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_avx512/cnProc_gen_BG1_avx512.c
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_cnProc_avx512/cnProc_gen_BG1_avx512.c
@@ -13,7 +13,7 @@ void nrLDPC_cnProc_BG1_generator_AVX512(uint16_t Z,int R)
  // 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]);
+  sprintf(fname,"../ldpc_gen_files/nrLDPC_cnProc_BG1_Z%d_R%s_AVX512.c",Z,ratestr[R]);
   FILE *fd=fopen(fname,"w");
   if (fd == NULL) {printf("Cannot create \n");abort();}
 
@@ -24,7 +24,7 @@ void nrLDPC_cnProc_BG1_generator_AVX512(uint16_t Z,int R)
   fprintf(fd,   "#define conditional_negate(a,b,z) _mm512_mask_sub_epi8(a,_mm512_movepi8_mask(b),z,a)\n");
 
 
-  fprintf(fd,"void nrLDPC_cnProc_BG1_Z%d_%s_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {\n",Z,ratestr[R]);
+  fprintf(fd,"void nrLDPC_cnProc_BG1_Z%d_R%s_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {\n",Z,ratestr[R]);
 
   const uint8_t*  lut_numCnInCnGroups;
   const uint32_t* lut_startAddrCnGroups = lut_startAddrCnGroups_BG1;
@@ -580,3 +580,4 @@ void nrLDPC_cnProc_BG1_generator_AVX512(uint16_t Z,int R)
 }//end of the function  nrLDPC_cnProc_BG1
 
 
+
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_avx512/cnProc_gen_BG2_avx512.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_cnProc_avx512/cnProc_gen_BG2_avx512.c
similarity index 98%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_avx512/cnProc_gen_BG2_avx512.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_cnProc_avx512/cnProc_gen_BG2_avx512.c
index 3d06fd9a39..392f076e90 100644
--- a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_avx512/cnProc_gen_BG2_avx512.c
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_cnProc_avx512/cnProc_gen_BG2_avx512.c
@@ -13,7 +13,7 @@ void nrLDPC_cnProc_BG2_generator_AVX512(uint16_t Z,int R)
  // system("mkdir -p ../ldpc_gen_files");
 
   char fname[50];
-  sprintf(fname,"../ldpc_gen_files/nrLDPC_cnProc_BG2_Z%d_%s_AVX512.c",Z,ratestr[R]);
+  sprintf(fname,"../ldpc_gen_files/nrLDPC_cnProc_BG2_Z%d_R%s_AVX512.c",Z,ratestr[R]);
   FILE *fd=fopen(fname,"w");
   if (fd == NULL) {printf("Cannot create \n");abort();}
 
@@ -24,7 +24,7 @@ void nrLDPC_cnProc_BG2_generator_AVX512(uint16_t Z,int R)
   fprintf(fd,   "#define conditional_negate(a,b,z) _mm512_mask_sub_epi8(a,_mm512_movepi8_mask(b),z,a)\n");
 
 
-  fprintf(fd,"void nrLDPC_cnProc_BG2_Z%d_%s_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {\n",Z,ratestr[R]);
+  fprintf(fd,"void nrLDPC_cnProc_BG2_Z%d_R%s_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {\n",Z,ratestr[R]);
 
   const uint8_t*  lut_numCnInCnGroups;
   const uint32_t* lut_startAddrCnGroups = lut_startAddrCnGroups_BG2;
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_avx512/cnProc_gen_avx512 b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_cnProc_avx512/cnProc_gen_avx512
similarity index 80%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_avx512/cnProc_gen_avx512
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_cnProc_avx512/cnProc_gen_avx512
index 8699a8d0a088a6d7e8bceb7a2fc505190d7b349e..de3b923c1f55f789bcf5a3598a8359a411c599c1 100755
GIT binary patch
delta 2975
zcmcIlYfw~W7(U-Qdv?!<l81}QvI3@5986s>5G!-NuNI1q)1Y`mMVCu}3z&hp;%(GX
z16~9a8&Su?OQvpSPMT<5($TzRlR1rf`5|V_&@iJpk@UXb?oPvx{Kx)yzxVmx=e>OA
zeCOFa*X5S$a%CKAI%H(X;U{|kwChH<%AYsi3AInWaBIoKy*VA;dU>zenmW=UIoF+U
zIo;mT;aoSS#ksP)MJnlWauQ_l7&Z&acqA)=T3*M7!oVOqo9vw(bSjKphL@syu`4h%
zI>vJQU5C_i<pEUiaMlLJ(RJ(?bdRyKYu;foN<TIQ93v+|<;WuRlu>!!!cl45zp1AN
zHd|9CgsGDyNlJ&|nUQIm(36?AhZfm#mKKu*#HM+l*i>)gqL|d|{9;Mg)Z?_NS?>8L
zhjB4AlArJ<TJ<RG$;|frZN~Bly_y59B;5`di&Th<+>fETk%F$GS*X3@Yp?j)E57y$
z6YUjQv^V+MEB^M6C~HGDRhy2jl#S$KH5y9Q%pPqsVP>Z3<Z2U+X#W&l%O-Shs*mGj
zNz%rnQJ>7kZAoiGqqcuUu0}!iAM$l=J{DJ>ksqN=v7p~Uejgs9pf523aeM+6Rha;G
zo{xu9J+eS4JdJ880yuawC8+{9`8BF+79fqg30MS3=Xa<aXLB%h4wtB0H?{zQi}#^w
z!E7#eE#x&+EkuA~zJ?-Uj2`b2K122(>cz$)TFz&v2qM^21S|M_DraSRNMFf|sX`Q6
zieN2YPZeHaWk{>!9-3zm+lZi^uOVO;ppkDRkRU)4uOW~qz(L+XU@#kiIbS*XHmaQ@
zrfcTS6dJ--V2d+SkekleV0nZnLft{f)TR<)C%KXqLz%niz?yav4&;v?a1o>CSUP}w
zfn57=avRZ@6ULI;hDS6HPDS^HFt{{7`HlOS%`^iWDOCqO`c5p#dJGk?by>)Q`4S5m
zk4Uac*OQ1EHAx_sei`1%O2~Mb`2D}Zh+O5=S7UYddYQ<+vrOMia7C?v&CB%N1dkjN
zuyUDxgy3(N1iV@vdY@ol_P`e|4=so9vSL{x{E^i=G7-;$SE^@hkOL>jizKWhg(pJ4
z1&`TXh+JsMyG<}=VH_I>`3tSd7JPe}dn?xDO2{yW;0I?Q)HAV=R{VvCM0Se2XoeFD
z<7^Lc0`0@U1i>C4{6MMg)h;Vbhe(%UYoYoT@8MirSsx%JAk^={ESJ^RgwI7=y<Ws?
zJH^jHwaZ}Da2#2s#M;mzSO){FJyazZT3tqxle*Nrh7)t;Y9MYwsGI1e*NzpD)=rUR
zn3!!%a^Sq$$E6}}f7^e4kr_*o?KL8j)+v$#+p-N-2ItVapcU;Ih|DqAGZ>v?$chRD
zIdN<>)Z^A!IE^+Qe$TP8onX#2*m<y{{RF0?-4CnKZh-^2R@-A5^z1E8N03JN2Wdd4
zXTiN(LpCW8oEKrMqlbPeC5ULt1GJ|^ivdSoym}4iO^1TK2v65b;&T<z)Af@0Tt)QY
zRqkR*L{a&FMf7yNBtBOW`{PCFGD$3l*n(u;CyCR95RoK8PJyk5Py9T%DOZvB)f6On
zg!sjG62IhqA}t_(73T!J>KDH+?+Vx$5WjXGxjgg`UT@Zi^}=scsaozA!)Yv0;O3>F
zrzl>{QUz`;3oXY)*8O|t5*w9ep^cDM7(2wTlVL-meIHs6ye#w^j`Z+=h{`bzvH72f
zdiNEMW2mBSi-d|syW?yFF+(e4LYdZ%^CblTg57irWV)>^6Uy9H85OhE9mgKRNw?M3
zj!~@)M9S4b3jJN_>ComjSPMiIS#9@7@>c#SSh~|+_%N}WU~-WaB`3GYuvL?4te+%A
zs&9Z5k5Dg#&ykf27mAGDK6(61u+jpowZt;X@IrBfEg5~S{;nWYb|N@nM6s2{LI&Ct
zC@Ci0+m6-+7to%8Hnh(mszm6XvxIbSQ3>f@Ly2LFCs{t~5t`OG!GDJ7Bvw1&S7e<B
zzL>OdFxvevbFpFDLK)wV2qJl#^Nv5GH$wd}>{x7NS@1QoO!RCnZWpZP0IQT(b<lyV
z7_aq%yFupnGqdvt&V#2FM)17+G<U(g*_n%%Bqbzz2d#)OLBXn?eD=t3iPG%Cf+DEc
s8s&AZvB_|#Gy;ySed67>?#F0+VHHh7SUntT8qSu(Q?xT-=$=>q1&b&{H2?qr

delta 2962
zcmcIkX-rgC6n^);c{A@)kq6Q+i-HQNGp>VH+-ezIafd`3m5AcTsvr#1iaLPS-3T1S
ztu3xmG_~kxYg!kytyN<zwKi$Qwqk50jg3@Wt%;PLb7!UvKk7f`$9d;F=R3=NbKlo|
zQ@(psF1NG2Cmbnq`26oCS;r`ki$iJ;to-?xw!ZxqWHx$t%14cs$)j9S;>NF<FTH4M
zOWZiNIdRRZW~ngb!c<7%QEUzrb1Tb-YQBRFh5kWKmgJoqbg>J&4m~0x*bNvK8D;um
zvP)|I`T>;kaP}D7kvrHK=oIB-4c?JaN;D*lng-iOxxp|x2M#BPdP_#TxCn+!`8RlS
z>hLaVi6lwM5T9mET92O0wEgsuP3P%hFl`Y*<3SNrzrlxMP&1dhC0SEXQ&2NC`Y6Zn
zVc11}><F}K9n_{}dj2qCdxT!ig;tV&3>Ob64<B+@hUV5#bQR4+;}zd{#W!B@jaQf$
zugGG&!8cy<kH1e<TQaHJFdU_9B^SHVQmSV3Xxj-hBW)*dHsFfR!|0mUqx-%3)GkYs
zHVTdUY(9o1?I9ZV#Wr%a9u#jSU)M%sbM<fX&Dtar`fcQQ=Rpek5+h*eqp_*V1aR_n
zJe=y01scjHP%lLQ7au@HssM?+jyf9!NaD!^Oajd07pNU)^RRRte~uH>SJ+|%8QenM
zg4ukG<?*f5EmQzE_fVz_qu0Bf&yYQcBG@=YC47X6z|5v2DC2WzI}6J}`Wn83I&@<z
z5p3XVsKaZl7-{7^mG&9Hwj$Wc7ZGp@u$Si$h!x-nFCZ{bfI7Z{z#!HSYtAI{?bLg)
z*sh+}P-+M(!x3LdLD_V^J*NAJ%<4WmrZ$KO`^l9wGgTg-18dp`aD3^6ezll2#?S%e
zBjh^c$)!7Ij2%brO+2D;&=hn#cY^B+<A&eCYNk1GkWx|S(f43W7BWo0merw)7fLL2
z0wTF$rrw{Z-KGhYp<jkK7R9DS62H%R%*Yjq`a<l^UN08acUS9ff@ReL*00vr5<GoE
z!1C346~SMx3)rwK>=MDA?13-6Dy#^uEQ(>F@Y|xU)=)ePUa41Of?T*cUL;{9DLfRS
z7e8h7U`=<(w~a71-OhT!(sWClg#VtFzZ-jUC3K`q@Pktj>a($t<~}7d)^?dcRXCS!
zw_U*vw0Hgz1ZRNoEtNJ_W>{D<STh{9ChA}M7VgEBO#xCYLcI}EGc2}!_+GSkH;H_8
zyZiyD%y6*Ha28nw#M;s<Saksw{fGKQXvuI4PM|4OeQ{&1Gz9V{gnBDws>g{;OS{Yf
zn3`!B9EJO8@2?Pf=bQfXi%NwuHB};$)GiYN?`1le8!n?wgBG;sz?$V?&tOcJL%wH#
z+$=jA2|F=#5H6vOhKE@eRtm;!2mS|6v^6jr?IBo;wi1qKTWpW$c7A!A(-EWu{~~)3
z>Zx!q+ab5g5S(MSmD5YVJ~W7EB>~!VqM5;!(_6iU`zAwfj@i@klK4_Z^mM!=zElxC
zc$GU?5>ZtCUlBbWFNrTz#6EaYI!qFaASO3X_etU`Aw(pJkd<o-@rj=YgK`ClUsZ0b
zM~GkVcH$RzOq2!0uk^Bj4Sw<axJkgh0r7j`Bd-cOir1TUXA$^qDitMuF`UH)3S7T3
z>{H5DvMB<$6o(aIA?tL5Wr#p|ao8?M%8MD|*U2tJB7GlP2woQY#UnjDAfj@VO9cND
zQSY(5@eIG<C(DG2M&{dXy|6;dV?voWjQ14;-@$3R1ZnveHXDlbEix)*b-tZlfeZN-
zTO($*Vh|+_fs*MYX36j*-@%%oTLH32^49z=SbCzr@kwIsgX97WI{?`Q4%=o@jZM>p
zNc9Y`dLz^e;3H&BgsTOPu0DDEP_U8$tPR9!WzgAewhcgE+u0-t<?RSjkl?m31yayP
zK%tv-uLf-zTt#~ho}hgO-3o>7B^HwIEh{A5+f(SUMU(h`;t`s*ccT9cvq`K<;U{F(
z11};i9EA1|%qeo%Dyic0gdmc)d6WDVT@mV!U|*4irNU>(YNb<Os}ZdF0BZ%Y%ApNe
zX0PS#rXXNt_TaRl<%44fN=wo*m-b)ajVm)740H2x3m|#7)w^z8qztLMtZ-t58P0Ba
g<~_CXRwTOz8;=ZO<#6#xJX;Q|HlEFZgxX&J0Hc~YHvj+t

diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_avx512/main.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_cnProc_avx512/main.c
similarity index 100%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_avx512/main.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_cnProc_avx512/main.c
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_cnProc_avx512/sauvegarde.tar.gz b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_cnProc_avx512/sauvegarde.tar.gz
new file mode 100644
index 0000000000000000000000000000000000000000..2cfcf359e2018dbaa4336f6016842c3274373394
GIT binary patch
literal 3870
zcmV+(58?11iwFSGq3m7&1MOY^ciK1-@2~Y=p~trGL81`L-)TzUHf*=sduiI2-rnwo
z<9Gy2;s#94hHl$z{`VWnHrU2C=1ah7q}M`_<<V#~8hu8xHN%c&SG!N{HHnZkMWNqB
z*Yxl=O++Nh6C!Im(G*>k$rH#C75xbk@0TqvP26$ELFkG5ExX*J>kl*uKUsEnFzK1-
zr919fqw3YGSe89zc|Egl*(N$YZl5Eh65-3p>LJ@X`Q>Ay-L*eDqi*~7Eoonxw&`@n
zBd7iPUw^7ZDo=m_(b{7S-<6}}+oXlJ!6zDms+KFlt$>1y=)6h!Y1MBfEMo<$Si?Ft
za19d?6M~6^iHwPYiHeDaiGd{%OA?k8ENNIWuq<L3Zq=|NVnxA<fmI2s8rDRtDOi`V
zAz}mQ!M!3-q4a<PfjbElCr}I&8Iu~26oELU3zQ_45(nx~RtAEyq1+t_f`I(gA30^(
zAgeAOA?qb=!jZMVU%8zXL3u=b-n3d+1nHos^W_s{8kB!32zOAEV~!_|U8V%?1e$iO
zi#%;V`T7F7!gQ?j<tu2)h9?AO|FtyxuPH<&%>K(TxKvdH`!DGV;r4$UDYyL(@=Dd}
zA^h{qP0#F(dZyEc$-%8&m4u~d1$0ggJUU}$9d$>xJ4W3r=#V`qZn|TqDT8${5xIm*
z68$i0C2C6%vihie_EJQD|BcRGNfmT^;{c_8x%6%@FfTg;bcUYy{$rQ$S>*_IE=JC{
zTsfk44jmpM_nSL5hvm}nx@S4);08g92E7|^9Q3V$>6R+27RF28?hMVQDz?DVBG<2n
zW#ZD@jfeBCKY!k9KX?76SGy&Aj)T^nwW#?<zrH(pgZBEpdVh3d+5zpqO6($SX}^c+
zb#(gs$w{cCjgD=PKwgds)DX0_aujMP%rgP2JzPrYQ+7jYF>5%4T(~kV86ydER4G6O
z&~ZI$Y>n*BplyTn$7Z>MFYxyYY7d9d==QMVUbo%JMccfw47e6#kG{|hcDZ~}!QXMG
zl2}<OMX@5HrIV`B9`7Nq!11Jy=W@<W7bHmaBGw60^_v9upuuF^wkN}e{myRKZ=KQP
z#yyG@lO<Y?7NbUF{JPh3f`X`?oKLx)>2JL*R=nvxp)Q|9ESEL=jL4J|bKsf*AyQeE
zhBQY*TAGGYo6@*NfnG8twCqcatc0=H?+!+;37s0#R`?gl6umzR|N0#HbxnW482-@j
zyXF{;N674Suh4}xMt@o3E6YY5bV*r6@aNcchAtZQk)|MY{B3N8DZwosk#}C3sMdM3
z>zha(DXMp->-sEF4v~zGPu-Y)A0DO^42CJtI{E#d-h~lk+oed7w!%f@tIinNrrD$N
zxG<qB7%{Ww-AJlTJ~S6#-~T3-W4h?%<cx_%s-lkFLozFa;U}XA7s&L2Iqp`&Qg>0u
zF{ykfwqG_bOH?L%fO`*RsX`<V)~<Yad}uOtw0d6~Y*4?IVUB1@El|_jTSCG89Y(j}
z^qWX`ck}iH#ZtRX4U&bv4~HT~VEQm}FKztYbVe>7cD{nJj*<*!oDRDI0WZFVgErBu
zwrf!XRmnxet1d!=c!sk~=OYk_9uV>kNy7MSiY@dCi4`XMTi>yOE;yYGFHDCD{n8uV
z{@`ewdg^r3aXK(+2Z0K~IG)|yFs%VA^`$eIfC|y+r)Pb!T<c<BqKj`p$uImK*iT_=
z?;PzTO|HCpr5y<~+MnoPzA}B?USV9*G^a?(Tm(jxa&vmtX0yuq``3Sld7|TOG`c}B
zMLEcXk8dy<1AeIt%AcwK_W7j@AK<-BeYc1km)6gWK;Q&gFQ50o1EltsO-=8aiUbK5
zd41usq3BwdcDTdJeanGyaeP{dmX9kXC^bmpraheooADv^xkVLbA6c!V9Ng0c!-Gn<
z?2nwi%9MDe`MkFeglJRBiL)To1(L4pCvtHp#haf{b7*vcOuW%CvP~DW#x5WL!#hNv
zbK!dT&)u0hNRw#*Z=tanVnLQzk3r|TCWT8>nbz+!vRt3}L^s}P#Ot&rgbu$zU=yRv
zOl@LMtk@N~C@1w$ETw4~ofhVmY|%)WQThsAkT)BIC?)ap3H&7!rfYXH7%!A;O7p#`
z1W*?R0g^#YCv60>Tyy}_$PxlxP(d)S(Ug;Fk`_{U?kOTvnBY}JC+12HZ7qM^i%$xb
zIZ^+p_O+a5VD|~_EpF;okRO@KkDI$kZte<i=;CUc#^qhue8W${``m^ztmJium9R4$
zUIBp4Ref&}WGRaa+(o6Sw7_Fz?jqg5p&L4e82E~zA6o2hNxZwu^tebdJuXrxkBcOD
zT#QhNu>`-%*WZxarOdfq!Cw&y4W?b8OEW_L{@Z)_*x$z%DB#cxQ;Zv*+Z-b)$*<dg
zG;SS9@(`3C%&m*^Fw?Z-h^8?`xUQ2UbWK+XuA_<-Ri;Hut%qgOJLP)LZObFrWwFe1
zB3}*9B=fx-rdh;iZd?<->F(j9oGdQ)LdFLm%`r?J3GxoW%$&IA3C_{m-_JXA?-^#1
zOn-7Qi)k2Z8z4)~3$oPMj>8OM5o3n2B%(z?7Td{<+84E{wg6}`lm*4HB1>3P3~Xrr
zvV0^XrWRR=uIvN72(6%kxeO>3EdHl~HmR7PO)3;<lU4(538+oo)MEML0aa4c{H;EE
zP^Ih?RHb(c2UQ$YJ(Q&*X+2D{!(}5aFQU;hmW@J?Mllv48m+0d0Msx<Q}ZACr4RWU
z^ts_+{V1Nf9I&Zr^CbPMR;L*76sPFdv<M%`#l%N)q41HsF?^(Pe6;LTEGJFH+M~xu
z>Q3=ddZ%!F#PQKX!AJ4~Uh~oOA|!pKjkN@Xq&M{zfTY;Y8ha&57U91Z-DQhjSPs`{
zNu<$ir*2)^K8MM)r!}ud+vji*{!)sGzm!7ZFJ)u+OHbWZ<ok;2LcEp1gpvd%^z{%P
z(S87or|lHurFRR*cpT$B6pW`lV2o$v#dt;r#*=0kkG-ms_3)I@G+Kc2ylp-9!n`iA
z1tt1wJbNYH@VEC8ujB_y>;;}Q;$F?`68Bh4A@0|_9_@fbMmq6|;;+AD06?{v08lLy
z08}>y01XZR3%JIoCP5A3(Xa98JH>zLox<@S$A1q6|EX)@znyM_*75?t+J*pNtyyaU
z2Al_gbXChkOLTWJ4g%v>R|JAdmCV54x|R5VFujrpC|swGfZNn60v^_{!bh+k%FKY7
zS}|d!Rw$UMrN1s7@N_eRabr3z<%k)ZsqE0KU_K~X<50AKP*h7oJ+(&<MU9<8(ezH?
zP?ST_Vn9)}7>jE6v=+GqBud1*P}D0K<uv-L!3>W^-!qtpqeN^Hu?3hEO;7(}$9Wob
zr<I=Hsd$HX&erx)uI2|>$lJoss>b7EGu3!3XH?_yv6*T-mNTmH_}EM}9?KckFg_N%
zbE_8<w(5m~t$Gq{Wt4>J#}c@dh#Z&}5SZ#o7zhmHV@Ia7og&kWUg6M`L(`o@(|n7h
z`UBo1C%G3%NiFsDS0(iJt0F9T5R%lIq}FN@f1T7{p7hr9yc6Q-yB7d;*jpX4MBmN8
zs$^hQ2dD=qNCWhvO8|m20~<t}z1X@5I?JFo<S*lHgn3^M+veSu*(O*Iq_Aby1Cecl
z^*{<+W<3zuCRh)ouw~W*k!^zYKnh!CJrLO@SP!JIW!3|cZG!bc3R`A95ZNYJ52UbV
z)_svJdU)L^rgv@>$~!mGyz`~~a=u|yM8Dif^Z@ye5!vmQQAW3L$DBLnJ9o@;KE7n!
z+m=!Ij%le-^bX<f@X!Q94K|w2nf-~~rL9N^UB-ip6*fiUe@XWk|0^~Aqe3(yvG`vi
z0SKzeEdH0Q^7vodNZW}2l@Z=CZ~QN{gr`Bk9$5S@iO2uCulQfmgN*+rtsDPK0=H46
zoU9T5OG=6%wq*P-DH20$z4%{3Y+-<Ud;r9}x`aZ62HV0`#iNJ}MiFM-cwV~qj-2;^
zNbrZwBYG8SHLWNSy_i`{iRiWLQd&YxuNBw1cu=n&Yn>~?!jBW_h6nZHQEm#o&c(xd
zEez+C(IjqNc^t6~Q05l)aa!0PHI7*HHE1#XjGxGO&wR`;97&8mJV76p&?PZ=o+I>w
zUXA>qhcPdBc7jI}%i--MMH5>!kl0iHC<Bl0#p8SN=NKN@a|~Hr^7vj4;uVM0;(Ntj
zaj1okff0?x@FyJN3vOURw`7SuH#&>LHO+`=Ms}jB{Xj87EvRBH14=DCM2|=L$^oX5
zqI~fHUkjP1i3j-N0lu<@!co=ZLRG~8HIF>NmmCUTu`pz5IKY>zv7_Kb|INoBbXGiX
zSx_Tu^ECac)*u;h6{F}?v=AEc0AD$vQBr^}9@}dn^EC0;UOcu}woo`U;?U>^itV)x
zbhJ|7hr^UZe<dZh*t103htLtTsYm`UeNb4^fxqd8{jNfO?x^35#C}LS<Tv$zUmpBx
z1K2Dn_}3=FK5%fhO8h4tlwr3)8PYq2gEJ1!^6mx}1EQ@Pnrp}Bj;($ouCUChw;5p=
z=>AxCC<d>@Qj1PmAsJ>BriEo#y~4!s4Dkx*LNu&fUo=!hN_Dev4V$XYZ$Nf+e)xz5
zAd&|V%K;*j0*LuM<v)LC{#;y+Ay<hZ#Sg9B@u9UDy~0r>N0B>U;@eJSuhiYo7^Yk6
za2!eS({9fHc;C4;>A4m6Sx5HyFQTXujh+8OG(}fMC`Uv^()sx>+enT2Ww$Fdem!~p
z_EY`f4|MPcfIcLg{Nm*ZZ~lDKsD};-@(u_RKAkn{=vnzMYtZX<oF3Y%b}Pb%<A2ah
zxb~vjtyf1CK>%VeAd6CgUvqTmHMpxHJpK7uxzVVggAsc6GkW%4$oE-*ybltM<NDLE
zW7*Zw3p7WidL;<Y>6PczZj91F7d?9k#2Nvucj(#ehmUVgU%xwR|Mubio4Z4L;!4MI
z2s*f=<NLrJ_v+nRO%SRdfBSIyZ>Vozc5F0s00-Zg4zz;)egPFZLv-Nuq3t6<2rm1@
zXIH0<|8Cv9K*Ce1Z3o}GU;4=HOum3gb9!bKGOL&05o=*L+(3FpWN;=^G=Fwh6JTtA
g5c5N}c;bmCo_OMkC!ToXiKmS8f2uNB=>W(80Gk$mzW@LL

literal 0
HcmV?d00001

diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z104_R13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z104_R13_AVX2.c
new file mode 100644
index 0000000000..5c9e0ba2c8
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z104_R13_AVX2.c
@@ -0,0 +1,978 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProc_BG1_Z104_R13_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes,  int8_t* llrRes ) {
+        __m256i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m256i* p_llrRes; 
+        __m256i* p_res; 
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [16128];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [16128];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [17664];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [17664];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [19584];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [19584];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [24192];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [24192];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<13;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<13;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<13;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<13;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<13;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<13;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<13;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [34944];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [34944];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [44160];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [44160];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [47616];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [47616];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<13;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<13;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<13;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<13;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<13;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<13;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<13;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[336];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<13;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[336 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[384];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<13;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[384 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[432];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<13;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[432 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 11 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [62976];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [62976];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[324];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[324 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[360];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[360 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [75648];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [75648];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<13;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<13;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<13;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<13;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<13;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<13;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<13;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[336];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<13;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[336 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[384];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<13;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[384 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[432];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<13;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[432 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[480];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<13;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[480 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[528];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<13;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[528 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [94080];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [94080];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [24960];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 14 CNs 
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+// Process group with <23 CNs 
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [99072];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [99072];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[264];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[264 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[276];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[276 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[300];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[300 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[312];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[312 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[324];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[324 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [109824];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [109824];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[264];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[264 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[276];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[276 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[300];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[300 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[312];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[312 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[324];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[324 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[336];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[336 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[348];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[348 + i]);
+            p_res++;
+            p_llrRes++;
+}
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z10_R13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z10_R13_AVX2.c
new file mode 100644
index 0000000000..17386fca34
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z10_R13_AVX2.c
@@ -0,0 +1,978 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProc_BG1_Z10_R13_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes,  int8_t* llrRes ) {
+        __m256i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m256i* p_llrRes; 
+        __m256i* p_res; 
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [16128];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [16128];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [17664];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [17664];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [19584];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [19584];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [24192];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [24192];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [34944];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [34944];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [44160];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [44160];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [47616];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [47616];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[336];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[336 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[384];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[384 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[432];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[432 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 11 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [62976];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [62976];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[324];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[324 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[360];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[360 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [75648];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [75648];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[336];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[336 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[384];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[384 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[432];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[432 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[480];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[480 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[528];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[528 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [94080];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [94080];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [24960];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 14 CNs 
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+// Process group with <23 CNs 
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [99072];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [99072];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[264];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[264 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[276];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[276 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[300];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[300 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[312];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[312 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[324];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[324 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [109824];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [109824];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[264];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[264 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[276];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[276 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[300];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[300 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[312];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[312 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[324];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[324 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[336];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[336 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[348];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[348 + i]);
+            p_res++;
+            p_llrRes++;
+}
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z112_R13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z112_R13_AVX2.c
new file mode 100644
index 0000000000..72f269a3fc
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z112_R13_AVX2.c
@@ -0,0 +1,978 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProc_BG1_Z112_R13_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes,  int8_t* llrRes ) {
+        __m256i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m256i* p_llrRes; 
+        __m256i* p_res; 
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [16128];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [16128];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [17664];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [17664];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [19584];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [19584];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [24192];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [24192];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<14;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<14;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<14;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<14;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<14;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<14;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<14;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [34944];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [34944];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [44160];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [44160];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [47616];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [47616];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<14;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<14;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<14;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<14;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<14;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<14;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<14;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[336];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<14;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[336 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[384];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<14;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[384 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[432];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<14;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[432 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 11 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [62976];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [62976];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[324];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[324 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[360];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[360 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [75648];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [75648];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<14;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<14;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<14;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<14;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<14;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<14;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<14;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[336];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<14;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[336 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[384];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<14;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[384 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[432];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<14;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[432 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[480];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<14;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[480 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[528];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<14;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[528 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [94080];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [94080];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [24960];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 14 CNs 
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+// Process group with <23 CNs 
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [99072];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [99072];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[264];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[264 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[276];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[276 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[300];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[300 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[312];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[312 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[324];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[324 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [109824];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [109824];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[264];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[264 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[276];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[276 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[300];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[300 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[312];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[312 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[324];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[324 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[336];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[336 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[348];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[348 + i]);
+            p_res++;
+            p_llrRes++;
+}
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z11_R13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z11_R13_AVX2.c
new file mode 100644
index 0000000000..59f30be553
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z11_R13_AVX2.c
@@ -0,0 +1,978 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProc_BG1_Z11_R13_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes,  int8_t* llrRes ) {
+        __m256i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m256i* p_llrRes; 
+        __m256i* p_res; 
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [16128];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [16128];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [17664];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [17664];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [19584];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [19584];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [24192];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [24192];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [34944];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [34944];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [44160];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [44160];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [47616];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [47616];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[336];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[336 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[384];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[384 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[432];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[432 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 11 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [62976];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [62976];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[324];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[324 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[360];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[360 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [75648];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [75648];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[336];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[336 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[384];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[384 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[432];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[432 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[480];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[480 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[528];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[528 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [94080];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [94080];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [24960];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 14 CNs 
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+// Process group with <23 CNs 
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [99072];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [99072];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[264];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[264 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[276];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[276 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[300];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[300 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[312];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[312 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[324];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[324 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [109824];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [109824];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[264];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[264 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[276];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[276 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[300];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[300 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[312];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[312 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[324];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[324 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[336];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[336 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[348];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[348 + i]);
+            p_res++;
+            p_llrRes++;
+}
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z120_R13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z120_R13_AVX2.c
new file mode 100644
index 0000000000..400c04c430
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z120_R13_AVX2.c
@@ -0,0 +1,978 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProc_BG1_Z120_R13_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes,  int8_t* llrRes ) {
+        __m256i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m256i* p_llrRes; 
+        __m256i* p_res; 
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [16128];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [16128];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [17664];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [17664];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [19584];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [19584];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [24192];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [24192];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<15;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<15;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<15;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<15;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<15;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<15;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<15;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [34944];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [34944];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [44160];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [44160];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [47616];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [47616];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<15;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<15;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<15;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<15;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<15;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<15;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<15;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[336];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<15;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[336 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[384];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<15;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[384 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[432];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<15;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[432 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 11 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [62976];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [62976];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[324];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[324 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[360];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[360 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [75648];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [75648];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<15;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<15;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<15;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<15;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<15;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<15;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<15;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[336];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<15;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[336 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[384];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<15;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[384 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[432];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<15;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[432 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[480];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<15;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[480 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[528];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<15;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[528 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [94080];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [94080];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [24960];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 14 CNs 
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+// Process group with <23 CNs 
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [99072];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [99072];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[264];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[264 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[276];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[276 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[300];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[300 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[312];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[312 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[324];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[324 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [109824];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [109824];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[264];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[264 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[276];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[276 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[300];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[300 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[312];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[312 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[324];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[324 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[336];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[336 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[348];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[348 + i]);
+            p_res++;
+            p_llrRes++;
+}
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z128_R13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z128_R13_AVX2.c
new file mode 100644
index 0000000000..6496593bd3
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z128_R13_AVX2.c
@@ -0,0 +1,978 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProc_BG1_Z128_R13_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes,  int8_t* llrRes ) {
+        __m256i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m256i* p_llrRes; 
+        __m256i* p_res; 
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [16128];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [16128];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [17664];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [17664];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [19584];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [19584];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [24192];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [24192];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<16;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<16;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<16;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<16;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<16;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<16;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<16;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [34944];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [34944];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [44160];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [44160];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [47616];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [47616];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<16;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<16;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<16;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<16;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<16;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<16;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<16;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[336];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<16;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[336 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[384];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<16;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[384 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[432];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<16;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[432 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 11 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [62976];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [62976];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[324];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[324 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[360];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[360 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [75648];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [75648];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<16;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<16;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<16;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<16;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<16;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<16;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<16;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[336];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<16;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[336 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[384];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<16;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[384 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[432];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<16;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[432 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[480];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<16;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[480 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[528];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<16;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[528 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [94080];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [94080];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [24960];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 14 CNs 
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+// Process group with <23 CNs 
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [99072];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [99072];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[264];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[264 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[276];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[276 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[300];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[300 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[312];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[312 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[324];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[324 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [109824];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [109824];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[264];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[264 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[276];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[276 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[300];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[300 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[312];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[312 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[324];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[324 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[336];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[336 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[348];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[348 + i]);
+            p_res++;
+            p_llrRes++;
+}
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z12_R13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z12_R13_AVX2.c
new file mode 100644
index 0000000000..0614cf505b
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z12_R13_AVX2.c
@@ -0,0 +1,978 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProc_BG1_Z12_R13_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes,  int8_t* llrRes ) {
+        __m256i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m256i* p_llrRes; 
+        __m256i* p_res; 
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [16128];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [16128];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [17664];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [17664];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [19584];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [19584];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [24192];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [24192];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [34944];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [34944];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [44160];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [44160];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [47616];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [47616];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[336];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[336 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[384];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[384 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[432];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[432 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 11 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [62976];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [62976];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[324];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[324 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[360];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[360 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [75648];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [75648];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[336];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[336 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[384];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[384 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[432];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[432 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[480];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[480 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[528];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[528 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [94080];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [94080];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [24960];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 14 CNs 
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+// Process group with <23 CNs 
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [99072];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [99072];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[264];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[264 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[276];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[276 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[300];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[300 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[312];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[312 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[324];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[324 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [109824];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [109824];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[264];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[264 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[276];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[276 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[300];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[300 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[312];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[312 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[324];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[324 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[336];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[336 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[348];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[348 + i]);
+            p_res++;
+            p_llrRes++;
+}
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z13_R13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z13_R13_AVX2.c
new file mode 100644
index 0000000000..785d554559
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z13_R13_AVX2.c
@@ -0,0 +1,978 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProc_BG1_Z13_R13_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes,  int8_t* llrRes ) {
+        __m256i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m256i* p_llrRes; 
+        __m256i* p_res; 
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [16128];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [16128];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [17664];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [17664];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [19584];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [19584];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [24192];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [24192];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [34944];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [34944];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [44160];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [44160];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [47616];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [47616];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[336];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[336 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[384];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[384 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[432];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[432 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 11 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [62976];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [62976];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[324];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[324 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[360];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[360 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [75648];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [75648];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[336];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[336 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[384];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[384 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[432];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[432 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[480];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[480 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[528];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[528 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [94080];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [94080];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [24960];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 14 CNs 
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+// Process group with <23 CNs 
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [99072];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [99072];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[264];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[264 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[276];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[276 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[300];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[300 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[312];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[312 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[324];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[324 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [109824];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [109824];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[264];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[264 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[276];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[276 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[300];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[300 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[312];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[312 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[324];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[324 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[336];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[336 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[348];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[348 + i]);
+            p_res++;
+            p_llrRes++;
+}
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z144_R13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z144_R13_AVX2.c
new file mode 100644
index 0000000000..d91cb1b44e
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z144_R13_AVX2.c
@@ -0,0 +1,978 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProc_BG1_Z144_R13_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes,  int8_t* llrRes ) {
+        __m256i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m256i* p_llrRes; 
+        __m256i* p_res; 
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [16128];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [16128];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [17664];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [17664];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [19584];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [19584];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [24192];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [24192];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<18;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<18;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<18;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<18;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<18;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<18;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<18;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [34944];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [34944];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<14;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<14;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<14;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<14;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<14;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<14;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<14;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<14;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [44160];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [44160];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [47616];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [47616];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<18;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<18;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<18;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<18;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<18;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<18;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<18;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[336];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<18;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[336 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[384];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<18;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[384 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[432];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<18;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[432 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 11 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [62976];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [62976];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<14;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<14;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<14;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<14;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<14;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<14;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<14;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<14;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<14;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[324];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<14;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[324 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[360];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<14;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[360 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [75648];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [75648];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<18;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<18;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<18;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<18;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<18;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<18;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<18;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[336];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<18;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[336 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[384];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<18;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[384 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[432];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<18;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[432 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[480];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<18;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[480 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[528];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<18;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[528 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [94080];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [94080];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [24960];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 14 CNs 
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+// Process group with <23 CNs 
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [99072];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [99072];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[264];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[264 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[276];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[276 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[300];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[300 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[312];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[312 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[324];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[324 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [109824];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [109824];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[264];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[264 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[276];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[276 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[300];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[300 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[312];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[312 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[324];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[324 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[336];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[336 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[348];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[348 + i]);
+            p_res++;
+            p_llrRes++;
+}
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z14_R13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z14_R13_AVX2.c
new file mode 100644
index 0000000000..07ba538e90
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z14_R13_AVX2.c
@@ -0,0 +1,978 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProc_BG1_Z14_R13_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes,  int8_t* llrRes ) {
+        __m256i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m256i* p_llrRes; 
+        __m256i* p_res; 
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [16128];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [16128];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [17664];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [17664];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [19584];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [19584];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [24192];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [24192];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [34944];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [34944];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [44160];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [44160];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [47616];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [47616];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[336];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[336 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[384];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[384 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[432];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[432 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 11 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [62976];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [62976];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[324];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[324 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[360];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[360 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [75648];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [75648];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[336];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[336 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[384];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[384 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[432];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[432 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[480];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[480 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[528];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[528 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [94080];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [94080];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [24960];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 14 CNs 
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+// Process group with <23 CNs 
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [99072];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [99072];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[264];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[264 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[276];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[276 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[300];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[300 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[312];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[312 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[324];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[324 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [109824];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [109824];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[264];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[264 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[276];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[276 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[300];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[300 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[312];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[312 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[324];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[324 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[336];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[336 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[348];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[348 + i]);
+            p_res++;
+            p_llrRes++;
+}
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z15_R13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z15_R13_AVX2.c
new file mode 100644
index 0000000000..78e3f8dc35
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z15_R13_AVX2.c
@@ -0,0 +1,978 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProc_BG1_Z15_R13_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes,  int8_t* llrRes ) {
+        __m256i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m256i* p_llrRes; 
+        __m256i* p_res; 
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [16128];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [16128];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [17664];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [17664];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [19584];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [19584];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [24192];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [24192];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [34944];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [34944];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [44160];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [44160];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [47616];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [47616];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[336];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[336 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[384];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[384 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[432];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[432 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 11 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [62976];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [62976];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[324];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[324 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[360];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[360 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [75648];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [75648];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[336];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[336 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[384];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[384 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[432];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[432 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[480];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[480 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[528];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[528 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [94080];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [94080];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [24960];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 14 CNs 
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+// Process group with <23 CNs 
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [99072];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [99072];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[264];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[264 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[276];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[276 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[300];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[300 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[312];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[312 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[324];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[324 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [109824];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [109824];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[264];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[264 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[276];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[276 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[300];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[300 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[312];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[312 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[324];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[324 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[336];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[336 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[348];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[348 + i]);
+            p_res++;
+            p_llrRes++;
+}
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z160_R13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z160_R13_AVX2.c
new file mode 100644
index 0000000000..cc2d9fafd7
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z160_R13_AVX2.c
@@ -0,0 +1,978 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProc_BG1_Z160_R13_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes,  int8_t* llrRes ) {
+        __m256i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m256i* p_llrRes; 
+        __m256i* p_res; 
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [16128];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [16128];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [17664];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [17664];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [19584];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [19584];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [24192];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [24192];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<20;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<20;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<20;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<20;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<20;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<20;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<20;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [34944];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [34944];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<15;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<15;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<15;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<15;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<15;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<15;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<15;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<15;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [44160];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [44160];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [47616];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [47616];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<20;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<20;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<20;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<20;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<20;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<20;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<20;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[336];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<20;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[336 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[384];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<20;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[384 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[432];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<20;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[432 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 11 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [62976];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [62976];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<15;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<15;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<15;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<15;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<15;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<15;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<15;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<15;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<15;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[324];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<15;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[324 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[360];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<15;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[360 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [75648];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [75648];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<20;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<20;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<20;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<20;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<20;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<20;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<20;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[336];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<20;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[336 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[384];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<20;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[384 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[432];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<20;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[432 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[480];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<20;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[480 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[528];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<20;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[528 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [94080];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [94080];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [24960];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 14 CNs 
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+// Process group with <23 CNs 
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [99072];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [99072];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[264];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[264 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[276];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[276 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[300];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[300 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[312];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[312 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[324];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[324 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [109824];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [109824];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[264];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[264 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[276];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[276 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[300];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[300 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[312];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[312 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[324];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[324 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[336];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[336 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[348];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[348 + i]);
+            p_res++;
+            p_llrRes++;
+}
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z16_R13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z16_R13_AVX2.c
new file mode 100644
index 0000000000..29ffb5058b
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z16_R13_AVX2.c
@@ -0,0 +1,978 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProc_BG1_Z16_R13_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes,  int8_t* llrRes ) {
+        __m256i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m256i* p_llrRes; 
+        __m256i* p_res; 
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [16128];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [16128];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [17664];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [17664];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [19584];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [19584];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [24192];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [24192];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [34944];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [34944];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [44160];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [44160];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [47616];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [47616];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[336];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[336 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[384];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[384 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[432];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[432 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 11 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [62976];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [62976];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[324];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[324 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[360];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[360 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [75648];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [75648];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[336];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[336 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[384];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[384 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[432];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[432 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[480];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[480 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[528];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[528 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [94080];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [94080];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [24960];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 14 CNs 
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+// Process group with <23 CNs 
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [99072];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [99072];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[264];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[264 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[276];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[276 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[300];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[300 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[312];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[312 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[324];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[324 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [109824];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [109824];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[264];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[264 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[276];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[276 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[300];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[300 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[312];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[312 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[324];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[324 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[336];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[336 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[348];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[348 + i]);
+            p_res++;
+            p_llrRes++;
+}
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z176_R13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z176_R13_AVX2.c
new file mode 100644
index 0000000000..e44d7cac94
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z176_R13_AVX2.c
@@ -0,0 +1,978 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProc_BG1_Z176_R13_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes,  int8_t* llrRes ) {
+        __m256i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m256i* p_llrRes; 
+        __m256i* p_res; 
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [16128];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [16128];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [17664];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [17664];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [19584];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [19584];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [24192];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [24192];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<22;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<22;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<22;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<22;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<22;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<22;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<22;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [34944];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [34944];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<17;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<17;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<17;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<17;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<17;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<17;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<17;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<17;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [44160];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [44160];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [47616];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [47616];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<22;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<22;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<22;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<22;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<22;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<22;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<22;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[336];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<22;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[336 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[384];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<22;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[384 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[432];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<22;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[432 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 11 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [62976];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [62976];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<17;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<17;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<17;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<17;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<17;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<17;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<17;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<17;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<17;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[324];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<17;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[324 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[360];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<17;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[360 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [75648];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [75648];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<22;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<22;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<22;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<22;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<22;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<22;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<22;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[336];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<22;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[336 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[384];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<22;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[384 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[432];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<22;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[432 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[480];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<22;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[480 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[528];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<22;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[528 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [94080];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [94080];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [24960];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 14 CNs 
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+// Process group with <23 CNs 
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [99072];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [99072];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[264];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[264 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[276];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[276 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[300];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[300 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[312];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[312 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[324];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[324 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [109824];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [109824];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[264];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[264 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[276];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[276 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[300];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[300 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[312];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[312 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[324];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[324 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[336];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[336 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[348];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[348 + i]);
+            p_res++;
+            p_llrRes++;
+}
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z18_R13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z18_R13_AVX2.c
new file mode 100644
index 0000000000..765ffaf0b1
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z18_R13_AVX2.c
@@ -0,0 +1,978 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProc_BG1_Z18_R13_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes,  int8_t* llrRes ) {
+        __m256i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m256i* p_llrRes; 
+        __m256i* p_res; 
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [16128];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [16128];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [17664];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [17664];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [19584];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [19584];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [24192];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [24192];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [34944];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [34944];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [44160];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [44160];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [47616];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [47616];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[336];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[336 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[384];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[384 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[432];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[432 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 11 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [62976];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [62976];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[324];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[324 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[360];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[360 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [75648];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [75648];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[336];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[336 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[384];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[384 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[432];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[432 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[480];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[480 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[528];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[528 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [94080];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [94080];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [24960];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 14 CNs 
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+// Process group with <23 CNs 
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [99072];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [99072];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[264];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[264 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[276];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[276 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[300];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[300 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[312];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[312 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[324];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[324 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [109824];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [109824];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[264];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[264 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[276];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[276 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[300];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[300 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[312];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[312 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[324];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[324 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[336];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[336 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[348];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[348 + i]);
+            p_res++;
+            p_llrRes++;
+}
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z192_R13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z192_R13_AVX2.c
new file mode 100644
index 0000000000..436effce12
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z192_R13_AVX2.c
@@ -0,0 +1,978 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProc_BG1_Z192_R13_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes,  int8_t* llrRes ) {
+        __m256i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m256i* p_llrRes; 
+        __m256i* p_res; 
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [16128];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [16128];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [17664];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [17664];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [19584];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [19584];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [24192];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [24192];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<24;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<24;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<24;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<24;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<24;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<24;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<24;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [34944];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [34944];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<18;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<18;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<18;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<18;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<18;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<18;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<18;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<18;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [44160];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [44160];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [47616];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [47616];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<24;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<24;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<24;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<24;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<24;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<24;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<24;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[336];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<24;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[336 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[384];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<24;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[384 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[432];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<24;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[432 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 11 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [62976];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [62976];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<18;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<18;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<18;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<18;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<18;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<18;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<18;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<18;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<18;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[324];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<18;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[324 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[360];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<18;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[360 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [75648];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [75648];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<24;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<24;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<24;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<24;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<24;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<24;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<24;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[336];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<24;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[336 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[384];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<24;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[384 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[432];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<24;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[432 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[480];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<24;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[480 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[528];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<24;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[528 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [94080];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [94080];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [24960];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 14 CNs 
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+// Process group with <23 CNs 
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [99072];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [99072];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[264];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[264 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[276];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[276 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[300];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[300 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[312];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[312 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[324];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[324 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [109824];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [109824];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[264];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[264 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[276];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[276 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[300];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[300 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[312];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[312 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[324];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[324 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[336];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[336 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[348];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[348 + i]);
+            p_res++;
+            p_llrRes++;
+}
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z208_R13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z208_R13_AVX2.c
new file mode 100644
index 0000000000..a043cee84d
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z208_R13_AVX2.c
@@ -0,0 +1,978 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProc_BG1_Z208_R13_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes,  int8_t* llrRes ) {
+        __m256i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m256i* p_llrRes; 
+        __m256i* p_res; 
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [16128];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [16128];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [17664];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [17664];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [19584];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [19584];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<13;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<13;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<13;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<13;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<13;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<13;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [24192];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [24192];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<26;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<26;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<26;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<26;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<26;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<26;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<26;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [34944];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [34944];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<20;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<20;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<20;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<20;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<20;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<20;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<20;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<20;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [44160];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [44160];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [47616];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [47616];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<26;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<26;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<26;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<26;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<26;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<26;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<26;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[336];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<26;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[336 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[384];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<26;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[384 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[432];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<26;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[432 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 11 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [62976];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [62976];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<20;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<20;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<20;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<20;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<20;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<20;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<20;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<20;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<20;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[324];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<20;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[324 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[360];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<20;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[360 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [75648];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [75648];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<26;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<26;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<26;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<26;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<26;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<26;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<26;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[336];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<26;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[336 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[384];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<26;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[384 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[432];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<26;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[432 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[480];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<26;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[480 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[528];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<26;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[528 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [94080];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [94080];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [24960];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 14 CNs 
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+// Process group with <23 CNs 
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [99072];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [99072];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[264];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[264 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[276];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[276 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[300];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[300 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[312];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[312 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[324];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[324 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [109824];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [109824];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[264];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[264 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[276];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[276 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[300];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[300 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[312];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[312 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[324];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[324 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[336];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[336 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[348];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[348 + i]);
+            p_res++;
+            p_llrRes++;
+}
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z20_R13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z20_R13_AVX2.c
new file mode 100644
index 0000000000..0acb046870
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z20_R13_AVX2.c
@@ -0,0 +1,978 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProc_BG1_Z20_R13_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes,  int8_t* llrRes ) {
+        __m256i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m256i* p_llrRes; 
+        __m256i* p_res; 
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [16128];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [16128];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [17664];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [17664];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [19584];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [19584];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [24192];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [24192];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [34944];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [34944];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [44160];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [44160];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [47616];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [47616];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[336];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[336 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[384];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[384 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[432];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[432 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 11 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [62976];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [62976];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[324];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[324 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[360];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[360 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [75648];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [75648];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[336];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[336 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[384];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[384 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[432];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[432 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[480];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[480 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[528];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[528 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [94080];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [94080];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [24960];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 14 CNs 
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+// Process group with <23 CNs 
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [99072];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [99072];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[264];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[264 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[276];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[276 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[300];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[300 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[312];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[312 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[324];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[324 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [109824];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [109824];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[264];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[264 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[276];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[276 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[300];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[300 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[312];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[312 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[324];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[324 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[336];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[336 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[348];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[348 + i]);
+            p_res++;
+            p_llrRes++;
+}
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z224_R13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z224_R13_AVX2.c
new file mode 100644
index 0000000000..941f05c829
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z224_R13_AVX2.c
@@ -0,0 +1,978 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProc_BG1_Z224_R13_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes,  int8_t* llrRes ) {
+        __m256i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m256i* p_llrRes; 
+        __m256i* p_res; 
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [16128];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [16128];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [17664];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [17664];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [19584];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [19584];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<14;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<14;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<14;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<14;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<14;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<14;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [24192];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [24192];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<28;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<28;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<28;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<28;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<28;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<28;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<28;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [34944];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [34944];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<21;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<21;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<21;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<21;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<21;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<21;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<21;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<21;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [44160];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [44160];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [47616];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [47616];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<28;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<28;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<28;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<28;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<28;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<28;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<28;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[336];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<28;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[336 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[384];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<28;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[384 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[432];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<28;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[432 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 11 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [62976];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [62976];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<21;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<21;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<21;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<21;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<21;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<21;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<21;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<21;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<21;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[324];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<21;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[324 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[360];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<21;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[360 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [75648];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [75648];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<28;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<28;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<28;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<28;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<28;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<28;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<28;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[336];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<28;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[336 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[384];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<28;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[384 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[432];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<28;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[432 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[480];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<28;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[480 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[528];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<28;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[528 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [94080];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [94080];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [24960];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 14 CNs 
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+// Process group with <23 CNs 
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [99072];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [99072];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[264];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[264 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[276];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[276 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[300];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[300 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[312];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[312 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[324];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[324 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [109824];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [109824];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[264];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[264 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[276];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[276 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[300];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[300 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[312];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[312 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[324];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[324 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[336];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[336 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[348];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[348 + i]);
+            p_res++;
+            p_llrRes++;
+}
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z22_R13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z22_R13_AVX2.c
new file mode 100644
index 0000000000..3bedc1da39
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z22_R13_AVX2.c
@@ -0,0 +1,978 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProc_BG1_Z22_R13_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes,  int8_t* llrRes ) {
+        __m256i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m256i* p_llrRes; 
+        __m256i* p_res; 
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [16128];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [16128];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [17664];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [17664];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [19584];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [19584];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [24192];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [24192];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [34944];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [34944];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [44160];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [44160];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [47616];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [47616];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[336];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[336 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[384];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[384 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[432];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[432 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 11 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [62976];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [62976];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[324];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[324 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[360];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[360 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [75648];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [75648];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[336];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[336 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[384];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[384 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[432];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[432 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[480];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[480 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[528];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[528 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [94080];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [94080];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [24960];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 14 CNs 
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+// Process group with <23 CNs 
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [99072];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [99072];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[264];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[264 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[276];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[276 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[300];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[300 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[312];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[312 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[324];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[324 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [109824];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [109824];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[264];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[264 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[276];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[276 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[300];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[300 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[312];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[312 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[324];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[324 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[336];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[336 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[348];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[348 + i]);
+            p_res++;
+            p_llrRes++;
+}
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z240_R13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z240_R13_AVX2.c
new file mode 100644
index 0000000000..3e1fb14b16
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z240_R13_AVX2.c
@@ -0,0 +1,978 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProc_BG1_Z240_R13_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes,  int8_t* llrRes ) {
+        __m256i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m256i* p_llrRes; 
+        __m256i* p_res; 
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [16128];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [16128];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [17664];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [17664];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [19584];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [19584];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<15;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<15;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<15;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<15;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<15;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<15;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [24192];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [24192];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<30;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<30;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<30;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<30;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<30;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<30;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<30;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [34944];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [34944];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<23;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<23;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<23;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<23;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<23;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<23;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<23;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<23;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [44160];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [44160];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [47616];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [47616];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<30;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<30;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<30;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<30;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<30;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<30;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<30;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[336];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<30;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[336 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[384];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<30;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[384 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[432];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<30;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[432 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 11 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [62976];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [62976];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<23;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<23;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<23;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<23;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<23;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<23;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<23;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<23;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<23;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[324];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<23;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[324 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[360];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<23;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[360 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [75648];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [75648];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<30;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<30;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<30;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<30;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<30;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<30;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<30;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[336];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<30;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[336 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[384];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<30;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[384 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[432];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<30;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[432 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[480];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<30;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[480 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[528];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<30;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[528 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [94080];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [94080];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [24960];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 14 CNs 
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+// Process group with <23 CNs 
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [99072];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [99072];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[264];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[264 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[276];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[276 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[300];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[300 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[312];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[312 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[324];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[324 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [109824];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [109824];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[264];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[264 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[276];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[276 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[300];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[300 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[312];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[312 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[324];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[324 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[336];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[336 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[348];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[348 + i]);
+            p_res++;
+            p_llrRes++;
+}
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z24_R13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z24_R13_AVX2.c
new file mode 100644
index 0000000000..a1a9e7c746
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z24_R13_AVX2.c
@@ -0,0 +1,978 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProc_BG1_Z24_R13_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes,  int8_t* llrRes ) {
+        __m256i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m256i* p_llrRes; 
+        __m256i* p_res; 
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [16128];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [16128];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [17664];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [17664];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [19584];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [19584];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [24192];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [24192];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [34944];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [34944];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [44160];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [44160];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [47616];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [47616];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[336];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[336 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[384];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[384 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[432];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[432 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 11 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [62976];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [62976];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[324];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[324 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[360];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[360 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [75648];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [75648];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[336];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[336 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[384];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[384 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[432];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[432 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[480];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[480 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[528];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[528 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [94080];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [94080];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [24960];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 14 CNs 
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+// Process group with <23 CNs 
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [99072];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [99072];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[264];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[264 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[276];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[276 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[300];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[300 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[312];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[312 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[324];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[324 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [109824];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [109824];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[264];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[264 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[276];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[276 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[300];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[300 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[312];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[312 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[324];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[324 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[336];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[336 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[348];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[348 + i]);
+            p_res++;
+            p_llrRes++;
+}
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z256_R13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z256_R13_AVX2.c
new file mode 100644
index 0000000000..95b6662869
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z256_R13_AVX2.c
@@ -0,0 +1,978 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProc_BG1_Z256_R13_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes,  int8_t* llrRes ) {
+        __m256i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m256i* p_llrRes; 
+        __m256i* p_res; 
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [16128];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [16128];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [17664];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [17664];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [19584];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [19584];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<16;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<16;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<16;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<16;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<16;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<16;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [24192];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [24192];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<32;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<32;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<32;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<32;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<32;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<32;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<32;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [34944];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [34944];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<24;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<24;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<24;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<24;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<24;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<24;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<24;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<24;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [44160];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [44160];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [47616];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [47616];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<32;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<32;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<32;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<32;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<32;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<32;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<32;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[336];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<32;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[336 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[384];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<32;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[384 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[432];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<32;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[432 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 11 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [62976];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [62976];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<24;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<24;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<24;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<24;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<24;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<24;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<24;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<24;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<24;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[324];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<24;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[324 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[360];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<24;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[360 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [75648];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [75648];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<32;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<32;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<32;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<32;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<32;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<32;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<32;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[336];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<32;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[336 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[384];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<32;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[384 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[432];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<32;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[432 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[480];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<32;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[480 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[528];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<32;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[528 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [94080];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [94080];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [24960];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 14 CNs 
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+// Process group with <23 CNs 
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [99072];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [99072];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[264];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[264 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[276];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[276 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[300];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[300 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[312];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[312 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[324];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[324 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [109824];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [109824];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[264];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[264 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[276];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[276 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[300];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[300 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[312];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[312 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[324];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[324 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[336];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[336 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[348];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[348 + i]);
+            p_res++;
+            p_llrRes++;
+}
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z26_R13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z26_R13_AVX2.c
new file mode 100644
index 0000000000..d67252e70d
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z26_R13_AVX2.c
@@ -0,0 +1,978 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProc_BG1_Z26_R13_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes,  int8_t* llrRes ) {
+        __m256i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m256i* p_llrRes; 
+        __m256i* p_res; 
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [16128];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [16128];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [17664];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [17664];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [19584];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [19584];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [24192];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [24192];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [34944];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [34944];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [44160];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [44160];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [47616];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [47616];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[336];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[336 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[384];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[384 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[432];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[432 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 11 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [62976];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [62976];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[324];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[324 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[360];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[360 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [75648];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [75648];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[336];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[336 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[384];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[384 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[432];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[432 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[480];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[480 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[528];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[528 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [94080];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [94080];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [24960];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 14 CNs 
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+// Process group with <23 CNs 
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [99072];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [99072];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[264];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[264 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[276];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[276 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[300];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[300 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[312];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[312 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[324];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[324 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [109824];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [109824];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[264];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[264 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[276];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[276 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[300];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[300 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[312];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[312 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[324];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[324 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[336];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[336 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[348];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[348 + i]);
+            p_res++;
+            p_llrRes++;
+}
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z288_R13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z288_R13_AVX2.c
new file mode 100644
index 0000000000..88b1453acd
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z288_R13_AVX2.c
@@ -0,0 +1,978 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProc_BG1_Z288_R13_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes,  int8_t* llrRes ) {
+        __m256i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m256i* p_llrRes; 
+        __m256i* p_res; 
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [16128];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [16128];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [17664];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [17664];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [19584];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [19584];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<18;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<18;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<18;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<18;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<18;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<18;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [24192];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [24192];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<36;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<36;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<36;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<36;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<36;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<36;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<36;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [34944];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [34944];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<27;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<27;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<27;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<27;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<27;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<27;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<27;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<27;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [44160];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [44160];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [47616];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [47616];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<36;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<36;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<36;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<36;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<36;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<36;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<36;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[336];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<36;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[336 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[384];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<36;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[384 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[432];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<36;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[432 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 11 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [62976];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [62976];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<27;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<27;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<27;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<27;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<27;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<27;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<27;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<27;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<27;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[324];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<27;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[324 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[360];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<27;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[360 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [75648];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [75648];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<36;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<36;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<36;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<36;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<36;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<36;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<36;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[336];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<36;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[336 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[384];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<36;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[384 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[432];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<36;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[432 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[480];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<36;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[480 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[528];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<36;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[528 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [94080];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [94080];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [24960];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 14 CNs 
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+// Process group with <23 CNs 
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [99072];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [99072];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[264];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[264 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[276];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[276 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[300];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[300 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[312];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[312 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[324];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[324 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [109824];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [109824];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[264];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[264 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[276];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[276 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[300];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[300 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[312];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[312 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[324];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[324 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[336];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[336 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[348];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[348 + i]);
+            p_res++;
+            p_llrRes++;
+}
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z28_R13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z28_R13_AVX2.c
new file mode 100644
index 0000000000..dab5d50a75
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z28_R13_AVX2.c
@@ -0,0 +1,978 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProc_BG1_Z28_R13_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes,  int8_t* llrRes ) {
+        __m256i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m256i* p_llrRes; 
+        __m256i* p_res; 
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [16128];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [16128];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [17664];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [17664];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [19584];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [19584];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [24192];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [24192];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [34944];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [34944];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [44160];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [44160];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [47616];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [47616];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[336];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[336 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[384];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[384 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[432];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[432 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 11 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [62976];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [62976];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[324];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[324 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[360];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[360 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [75648];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [75648];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[336];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[336 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[384];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[384 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[432];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[432 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[480];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[480 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[528];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[528 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [94080];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [94080];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [24960];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 14 CNs 
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+// Process group with <23 CNs 
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [99072];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [99072];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[264];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[264 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[276];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[276 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[300];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[300 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[312];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[312 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[324];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[324 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [109824];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [109824];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[264];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[264 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[276];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[276 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[300];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[300 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[312];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[312 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[324];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[324 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[336];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[336 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[348];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[348 + i]);
+            p_res++;
+            p_llrRes++;
+}
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z2_R13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z2_R13_AVX2.c
new file mode 100644
index 0000000000..b5b4329183
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z2_R13_AVX2.c
@@ -0,0 +1,978 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProc_BG1_Z2_R13_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes,  int8_t* llrRes ) {
+        __m256i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m256i* p_llrRes; 
+        __m256i* p_res; 
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [16128];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [16128];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [17664];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [17664];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [19584];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [19584];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [24192];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [24192];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [34944];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [34944];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [44160];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [44160];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [47616];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [47616];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[336];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[336 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[384];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[384 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[432];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[432 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 11 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [62976];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [62976];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[324];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[324 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[360];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[360 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [75648];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [75648];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[336];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[336 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[384];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[384 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[432];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[432 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[480];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[480 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[528];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[528 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [94080];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [94080];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [24960];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 14 CNs 
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+// Process group with <23 CNs 
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [99072];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [99072];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[264];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[264 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[276];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[276 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[300];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[300 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[312];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[312 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[324];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[324 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [109824];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [109824];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[264];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[264 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[276];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[276 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[300];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[300 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[312];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[312 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[324];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[324 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[336];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[336 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[348];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[348 + i]);
+            p_res++;
+            p_llrRes++;
+}
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z30_R13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z30_R13_AVX2.c
new file mode 100644
index 0000000000..82b7429182
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z30_R13_AVX2.c
@@ -0,0 +1,978 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProc_BG1_Z30_R13_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes,  int8_t* llrRes ) {
+        __m256i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m256i* p_llrRes; 
+        __m256i* p_res; 
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [16128];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [16128];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [17664];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [17664];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [19584];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [19584];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [24192];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [24192];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [34944];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [34944];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [44160];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [44160];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [47616];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [47616];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[336];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[336 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[384];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[384 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[432];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[432 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 11 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [62976];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [62976];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[324];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[324 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[360];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[360 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [75648];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [75648];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[336];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[336 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[384];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[384 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[432];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[432 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[480];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[480 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[528];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[528 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [94080];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [94080];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [24960];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 14 CNs 
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+// Process group with <23 CNs 
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [99072];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [99072];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[264];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[264 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[276];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[276 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[300];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[300 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[312];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[312 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[324];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[324 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [109824];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [109824];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[264];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[264 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[276];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[276 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[300];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[300 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[312];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[312 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[324];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[324 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[336];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[336 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[348];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[348 + i]);
+            p_res++;
+            p_llrRes++;
+}
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z320_R13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z320_R13_AVX2.c
new file mode 100644
index 0000000000..c1243fe104
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z320_R13_AVX2.c
@@ -0,0 +1,978 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProc_BG1_Z320_R13_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes,  int8_t* llrRes ) {
+        __m256i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m256i* p_llrRes; 
+        __m256i* p_res; 
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [16128];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [16128];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [17664];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [17664];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [19584];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [19584];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<20;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<20;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<20;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<20;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<20;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<20;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [24192];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [24192];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<40;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<40;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<40;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<40;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<40;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<40;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<40;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [34944];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [34944];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<30;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<30;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<30;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<30;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<30;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<30;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<30;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<30;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [44160];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [44160];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [47616];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [47616];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<40;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<40;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<40;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<40;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<40;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<40;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<40;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[336];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<40;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[336 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[384];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<40;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[384 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[432];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<40;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[432 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 11 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [62976];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [62976];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<30;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<30;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<30;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<30;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<30;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<30;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<30;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<30;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<30;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[324];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<30;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[324 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[360];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<30;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[360 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [75648];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [75648];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<40;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<40;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<40;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<40;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<40;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<40;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<40;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[336];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<40;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[336 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[384];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<40;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[384 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[432];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<40;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[432 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[480];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<40;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[480 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[528];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<40;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[528 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [94080];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [94080];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [24960];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 14 CNs 
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+// Process group with <23 CNs 
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [99072];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [99072];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[264];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[264 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[276];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[276 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[300];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[300 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[312];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[312 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[324];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[324 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [109824];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [109824];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[264];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[264 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[276];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[276 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[300];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[300 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[312];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[312 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[324];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[324 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[336];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[336 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[348];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[348 + i]);
+            p_res++;
+            p_llrRes++;
+}
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z32_R13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z32_R13_AVX2.c
new file mode 100644
index 0000000000..6fbf2f7060
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z32_R13_AVX2.c
@@ -0,0 +1,978 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProc_BG1_Z32_R13_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes,  int8_t* llrRes ) {
+        __m256i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m256i* p_llrRes; 
+        __m256i* p_res; 
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [16128];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [16128];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [17664];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [17664];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [19584];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [19584];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [24192];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [24192];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [34944];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [34944];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [44160];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [44160];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [47616];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [47616];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[336];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[336 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[384];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[384 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[432];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[432 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 11 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [62976];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [62976];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[324];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[324 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[360];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[360 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [75648];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [75648];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[336];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[336 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[384];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[384 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[432];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[432 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[480];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[480 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[528];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[528 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [94080];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [94080];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [24960];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 14 CNs 
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+// Process group with <23 CNs 
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [99072];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [99072];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[264];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[264 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[276];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[276 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[300];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[300 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[312];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[312 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[324];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[324 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [109824];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [109824];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[264];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[264 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[276];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[276 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[300];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[300 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[312];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[312 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[324];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[324 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[336];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[336 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[348];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[348 + i]);
+            p_res++;
+            p_llrRes++;
+}
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z352_R13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z352_R13_AVX2.c
new file mode 100644
index 0000000000..54bf723732
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z352_R13_AVX2.c
@@ -0,0 +1,978 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProc_BG1_Z352_R13_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes,  int8_t* llrRes ) {
+        __m256i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m256i* p_llrRes; 
+        __m256i* p_res; 
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [16128];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [16128];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [17664];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [17664];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [19584];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [19584];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<22;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<22;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<22;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<22;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<22;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<22;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [24192];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [24192];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<44;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<44;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<44;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<44;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<44;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<44;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<44;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [34944];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [34944];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<33;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<33;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<33;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<33;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<33;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<33;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<33;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<33;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [44160];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [44160];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [47616];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [47616];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<44;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<44;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<44;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<44;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<44;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<44;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<44;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[336];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<44;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[336 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[384];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<44;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[384 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[432];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<44;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[432 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 11 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [62976];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [62976];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<33;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<33;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<33;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<33;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<33;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<33;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<33;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<33;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<33;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[324];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<33;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[324 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[360];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<33;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[360 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [75648];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [75648];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<44;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<44;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<44;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<44;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<44;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<44;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<44;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[336];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<44;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[336 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[384];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<44;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[384 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[432];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<44;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[432 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[480];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<44;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[480 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[528];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<44;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[528 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [94080];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [94080];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [24960];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 14 CNs 
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+// Process group with <23 CNs 
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [99072];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [99072];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[264];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[264 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[276];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[276 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[300];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[300 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[312];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[312 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[324];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[324 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [109824];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [109824];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[264];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[264 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[276];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[276 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[300];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[300 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[312];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[312 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[324];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[324 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[336];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[336 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[348];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[348 + i]);
+            p_res++;
+            p_llrRes++;
+}
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z36_R13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z36_R13_AVX2.c
new file mode 100644
index 0000000000..449662b84f
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z36_R13_AVX2.c
@@ -0,0 +1,978 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProc_BG1_Z36_R13_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes,  int8_t* llrRes ) {
+        __m256i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m256i* p_llrRes; 
+        __m256i* p_res; 
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [16128];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [16128];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [17664];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [17664];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [19584];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [19584];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [24192];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [24192];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [34944];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [34944];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [44160];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [44160];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [47616];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [47616];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[336];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[336 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[384];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[384 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[432];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[432 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 11 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [62976];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [62976];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[324];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[324 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[360];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[360 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [75648];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [75648];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[336];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[336 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[384];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[384 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[432];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[432 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[480];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[480 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[528];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[528 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [94080];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [94080];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [24960];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 14 CNs 
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+// Process group with <23 CNs 
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [99072];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [99072];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[264];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[264 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[276];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[276 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[300];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[300 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[312];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[312 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[324];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[324 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [109824];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [109824];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[264];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[264 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[276];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[276 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[300];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[300 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[312];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[312 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[324];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[324 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[336];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[336 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[348];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[348 + i]);
+            p_res++;
+            p_llrRes++;
+}
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z384_R13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z384_R13_AVX2.c
new file mode 100644
index 0000000000..c4fa11327f
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z384_R13_AVX2.c
@@ -0,0 +1,978 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProc_BG1_Z384_R13_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes,  int8_t* llrRes ) {
+        __m256i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m256i* p_llrRes; 
+        __m256i* p_res; 
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [16128];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [16128];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [17664];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [17664];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [19584];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [19584];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<24;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<24;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<24;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<24;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<24;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<24;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [24192];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [24192];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<48;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<48;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<48;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<48;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<48;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<48;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<48;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [34944];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [34944];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<36;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<36;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<36;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<36;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<36;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<36;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<36;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<36;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [44160];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [44160];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [47616];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [47616];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<48;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<48;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<48;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<48;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<48;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<48;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<48;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[336];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<48;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[336 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[384];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<48;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[384 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[432];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<48;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[432 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 11 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [62976];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [62976];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<36;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<36;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<36;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<36;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<36;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<36;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<36;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<36;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<36;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[324];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<36;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[324 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[360];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<36;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[360 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [75648];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [75648];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<48;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<48;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<48;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<48;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<48;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<48;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<48;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[336];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<48;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[336 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[384];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<48;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[384 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[432];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<48;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[432 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[480];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<48;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[480 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[528];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<48;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[528 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [94080];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [94080];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [24960];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 14 CNs 
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+// Process group with <23 CNs 
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [99072];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [99072];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[264];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[264 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[276];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[276 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[300];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[300 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[312];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[312 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[324];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[324 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [109824];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [109824];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[264];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[264 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[276];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[276 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[300];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[300 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[312];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[312 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[324];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[324 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[336];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[336 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[348];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[348 + i]);
+            p_res++;
+            p_llrRes++;
+}
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z3_R13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z3_R13_AVX2.c
new file mode 100644
index 0000000000..cd0ecff86e
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z3_R13_AVX2.c
@@ -0,0 +1,978 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProc_BG1_Z3_R13_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes,  int8_t* llrRes ) {
+        __m256i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m256i* p_llrRes; 
+        __m256i* p_res; 
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [16128];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [16128];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [17664];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [17664];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [19584];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [19584];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [24192];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [24192];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [34944];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [34944];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [44160];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [44160];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [47616];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [47616];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[336];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[336 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[384];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[384 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[432];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[432 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 11 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [62976];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [62976];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[324];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[324 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[360];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[360 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [75648];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [75648];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[336];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[336 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[384];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[384 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[432];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[432 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[480];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[480 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[528];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[528 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [94080];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [94080];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [24960];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 14 CNs 
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+// Process group with <23 CNs 
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [99072];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [99072];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[264];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[264 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[276];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[276 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[300];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[300 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[312];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[312 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[324];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[324 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [109824];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [109824];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[264];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[264 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[276];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[276 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[300];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[300 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[312];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[312 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[324];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[324 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[336];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[336 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[348];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[348 + i]);
+            p_res++;
+            p_llrRes++;
+}
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z40_R13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z40_R13_AVX2.c
new file mode 100644
index 0000000000..b0a1d96998
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z40_R13_AVX2.c
@@ -0,0 +1,978 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProc_BG1_Z40_R13_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes,  int8_t* llrRes ) {
+        __m256i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m256i* p_llrRes; 
+        __m256i* p_res; 
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [16128];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [16128];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [17664];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [17664];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [19584];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [19584];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [24192];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [24192];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [34944];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [34944];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [44160];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [44160];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [47616];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [47616];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[336];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[336 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[384];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[384 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[432];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[432 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 11 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [62976];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [62976];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[324];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[324 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[360];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[360 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [75648];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [75648];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[336];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[336 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[384];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[384 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[432];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[432 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[480];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[480 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[528];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[528 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [94080];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [94080];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [24960];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 14 CNs 
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+// Process group with <23 CNs 
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [99072];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [99072];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[264];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[264 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[276];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[276 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[300];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[300 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[312];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[312 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[324];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[324 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [109824];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [109824];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[264];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[264 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[276];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[276 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[300];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[300 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[312];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[312 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[324];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[324 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[336];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[336 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[348];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[348 + i]);
+            p_res++;
+            p_llrRes++;
+}
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z44_R13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z44_R13_AVX2.c
new file mode 100644
index 0000000000..094471b418
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z44_R13_AVX2.c
@@ -0,0 +1,978 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProc_BG1_Z44_R13_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes,  int8_t* llrRes ) {
+        __m256i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m256i* p_llrRes; 
+        __m256i* p_res; 
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [16128];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [16128];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [17664];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [17664];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [19584];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [19584];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [24192];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [24192];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [34944];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [34944];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [44160];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [44160];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [47616];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [47616];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[336];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[336 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[384];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[384 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[432];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[432 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 11 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [62976];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [62976];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[324];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[324 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[360];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[360 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [75648];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [75648];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[336];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[336 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[384];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[384 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[432];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[432 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[480];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[480 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[528];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[528 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [94080];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [94080];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [24960];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 14 CNs 
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+// Process group with <23 CNs 
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [99072];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [99072];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[264];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[264 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[276];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[276 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[300];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[300 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[312];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[312 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[324];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[324 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [109824];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [109824];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[264];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[264 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[276];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[276 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[300];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[300 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[312];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[312 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[324];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[324 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[336];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[336 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[348];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[348 + i]);
+            p_res++;
+            p_llrRes++;
+}
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z48_R13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z48_R13_AVX2.c
new file mode 100644
index 0000000000..b5384c2cd2
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z48_R13_AVX2.c
@@ -0,0 +1,978 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProc_BG1_Z48_R13_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes,  int8_t* llrRes ) {
+        __m256i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m256i* p_llrRes; 
+        __m256i* p_res; 
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [16128];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [16128];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [17664];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [17664];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [19584];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [19584];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [24192];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [24192];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [34944];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [34944];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [44160];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [44160];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [47616];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [47616];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[336];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[336 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[384];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[384 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[432];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[432 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 11 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [62976];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [62976];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[324];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[324 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[360];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[360 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [75648];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [75648];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[336];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[336 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[384];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[384 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[432];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[432 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[480];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[480 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[528];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[528 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [94080];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [94080];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [24960];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 14 CNs 
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+// Process group with <23 CNs 
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [99072];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [99072];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[264];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[264 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[276];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[276 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[300];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[300 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[312];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[312 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[324];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[324 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [109824];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [109824];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[264];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[264 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[276];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[276 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[300];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[300 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[312];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[312 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[324];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[324 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[336];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[336 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[348];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[348 + i]);
+            p_res++;
+            p_llrRes++;
+}
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z4_R13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z4_R13_AVX2.c
new file mode 100644
index 0000000000..1c664a4a07
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z4_R13_AVX2.c
@@ -0,0 +1,978 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProc_BG1_Z4_R13_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes,  int8_t* llrRes ) {
+        __m256i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m256i* p_llrRes; 
+        __m256i* p_res; 
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [16128];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [16128];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [17664];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [17664];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [19584];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [19584];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [24192];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [24192];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [34944];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [34944];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [44160];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [44160];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [47616];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [47616];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[336];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[336 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[384];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[384 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[432];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[432 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 11 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [62976];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [62976];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[324];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[324 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[360];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[360 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [75648];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [75648];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[336];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[336 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[384];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[384 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[432];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[432 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[480];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[480 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[528];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[528 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [94080];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [94080];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [24960];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 14 CNs 
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+// Process group with <23 CNs 
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [99072];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [99072];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[264];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[264 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[276];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[276 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[300];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[300 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[312];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[312 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[324];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[324 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [109824];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [109824];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[264];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[264 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[276];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[276 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[300];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[300 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[312];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[312 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[324];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[324 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[336];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[336 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[348];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[348 + i]);
+            p_res++;
+            p_llrRes++;
+}
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z52_R13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z52_R13_AVX2.c
new file mode 100644
index 0000000000..ebea97e7a4
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z52_R13_AVX2.c
@@ -0,0 +1,978 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProc_BG1_Z52_R13_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes,  int8_t* llrRes ) {
+        __m256i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m256i* p_llrRes; 
+        __m256i* p_res; 
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [16128];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [16128];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [17664];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [17664];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [19584];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [19584];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [24192];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [24192];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [34944];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [34944];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [44160];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [44160];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [47616];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [47616];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[336];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[336 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[384];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[384 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[432];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[432 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 11 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [62976];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [62976];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[324];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[324 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[360];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[360 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [75648];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [75648];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[336];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[336 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[384];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[384 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[432];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[432 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[480];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[480 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[528];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[528 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [94080];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [94080];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [24960];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 14 CNs 
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+// Process group with <23 CNs 
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [99072];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [99072];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[264];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[264 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[276];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[276 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[300];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[300 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[312];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[312 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[324];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[324 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [109824];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [109824];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[264];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[264 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[276];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[276 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[300];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[300 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[312];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[312 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[324];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[324 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[336];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[336 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[348];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[348 + i]);
+            p_res++;
+            p_llrRes++;
+}
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z56_R13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z56_R13_AVX2.c
new file mode 100644
index 0000000000..c24d31dc62
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z56_R13_AVX2.c
@@ -0,0 +1,978 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProc_BG1_Z56_R13_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes,  int8_t* llrRes ) {
+        __m256i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m256i* p_llrRes; 
+        __m256i* p_res; 
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [16128];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [16128];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [17664];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [17664];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [19584];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [19584];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [24192];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [24192];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [34944];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [34944];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [44160];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [44160];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [47616];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [47616];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[336];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[336 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[384];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[384 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[432];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[432 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 11 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [62976];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [62976];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[324];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[324 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[360];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[360 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [75648];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [75648];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[336];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[336 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[384];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[384 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[432];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[432 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[480];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[480 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[528];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[528 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [94080];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [94080];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [24960];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 14 CNs 
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+// Process group with <23 CNs 
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [99072];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [99072];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[264];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[264 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[276];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[276 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[300];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[300 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[312];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[312 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[324];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[324 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [109824];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [109824];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[264];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[264 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[276];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[276 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[300];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[300 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[312];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[312 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[324];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[324 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[336];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[336 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[348];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[348 + i]);
+            p_res++;
+            p_llrRes++;
+}
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z5_R13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z5_R13_AVX2.c
new file mode 100644
index 0000000000..3d0523df04
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z5_R13_AVX2.c
@@ -0,0 +1,978 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProc_BG1_Z5_R13_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes,  int8_t* llrRes ) {
+        __m256i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m256i* p_llrRes; 
+        __m256i* p_res; 
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [16128];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [16128];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [17664];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [17664];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [19584];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [19584];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [24192];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [24192];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [34944];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [34944];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [44160];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [44160];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [47616];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [47616];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[336];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[336 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[384];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[384 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[432];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[432 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 11 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [62976];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [62976];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[324];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[324 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[360];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[360 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [75648];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [75648];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[336];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[336 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[384];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[384 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[432];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[432 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[480];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[480 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[528];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[528 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [94080];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [94080];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [24960];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 14 CNs 
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+// Process group with <23 CNs 
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [99072];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [99072];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[264];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[264 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[276];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[276 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[300];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[300 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[312];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[312 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[324];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[324 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [109824];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [109824];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[264];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[264 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[276];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[276 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[300];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[300 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[312];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[312 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[324];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[324 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[336];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[336 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[348];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[348 + i]);
+            p_res++;
+            p_llrRes++;
+}
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z60_R13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z60_R13_AVX2.c
new file mode 100644
index 0000000000..b69c8bfb2c
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z60_R13_AVX2.c
@@ -0,0 +1,978 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProc_BG1_Z60_R13_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes,  int8_t* llrRes ) {
+        __m256i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m256i* p_llrRes; 
+        __m256i* p_res; 
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [16128];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [16128];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [17664];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [17664];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [19584];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [19584];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [24192];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [24192];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [34944];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [34944];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [44160];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [44160];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [47616];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [47616];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[336];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[336 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[384];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[384 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[432];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[432 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 11 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [62976];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [62976];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[324];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[324 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[360];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[360 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [75648];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [75648];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[336];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[336 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[384];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[384 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[432];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[432 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[480];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[480 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[528];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[528 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [94080];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [94080];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [24960];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 14 CNs 
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+// Process group with <23 CNs 
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [99072];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [99072];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[264];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[264 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[276];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[276 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[300];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[300 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[312];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[312 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[324];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[324 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [109824];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [109824];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[264];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[264 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[276];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[276 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[300];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[300 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[312];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[312 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[324];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[324 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[336];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[336 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[348];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[348 + i]);
+            p_res++;
+            p_llrRes++;
+}
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z64_R13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z64_R13_AVX2.c
new file mode 100644
index 0000000000..1c51ee482f
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z64_R13_AVX2.c
@@ -0,0 +1,978 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProc_BG1_Z64_R13_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes,  int8_t* llrRes ) {
+        __m256i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m256i* p_llrRes; 
+        __m256i* p_res; 
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [16128];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [16128];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [17664];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [17664];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [19584];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [19584];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [24192];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [24192];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [34944];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [34944];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [44160];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [44160];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [47616];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [47616];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[336];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[336 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[384];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[384 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[432];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[432 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 11 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [62976];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [62976];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[324];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[324 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[360];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[360 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [75648];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [75648];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[336];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[336 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[384];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[384 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[432];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[432 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[480];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[480 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[528];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[528 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [94080];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [94080];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [24960];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 14 CNs 
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+// Process group with <23 CNs 
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [99072];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [99072];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[264];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[264 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[276];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[276 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[300];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[300 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[312];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[312 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[324];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[324 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [109824];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [109824];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[264];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[264 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[276];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[276 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[300];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[300 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[312];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[312 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[324];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[324 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[336];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[336 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[348];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[348 + i]);
+            p_res++;
+            p_llrRes++;
+}
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z6_R13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z6_R13_AVX2.c
new file mode 100644
index 0000000000..bbe6ddcb3e
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z6_R13_AVX2.c
@@ -0,0 +1,978 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProc_BG1_Z6_R13_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes,  int8_t* llrRes ) {
+        __m256i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m256i* p_llrRes; 
+        __m256i* p_res; 
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [16128];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [16128];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [17664];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [17664];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [19584];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [19584];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [24192];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [24192];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [34944];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [34944];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [44160];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [44160];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [47616];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [47616];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[336];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[336 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[384];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[384 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[432];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[432 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 11 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [62976];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [62976];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[324];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[324 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[360];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[360 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [75648];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [75648];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[336];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[336 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[384];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[384 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[432];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[432 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[480];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[480 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[528];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[528 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [94080];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [94080];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [24960];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 14 CNs 
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+// Process group with <23 CNs 
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [99072];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [99072];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[264];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[264 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[276];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[276 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[300];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[300 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[312];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[312 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[324];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[324 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [109824];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [109824];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[264];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[264 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[276];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[276 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[300];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[300 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[312];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[312 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[324];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[324 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[336];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[336 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[348];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[348 + i]);
+            p_res++;
+            p_llrRes++;
+}
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z72_R13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z72_R13_AVX2.c
new file mode 100644
index 0000000000..f74cc89ad7
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z72_R13_AVX2.c
@@ -0,0 +1,978 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProc_BG1_Z72_R13_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes,  int8_t* llrRes ) {
+        __m256i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m256i* p_llrRes; 
+        __m256i* p_res; 
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [16128];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [16128];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [17664];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [17664];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [19584];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [19584];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [24192];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [24192];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [34944];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [34944];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [44160];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [44160];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [47616];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [47616];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[336];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[336 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[384];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[384 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[432];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[432 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 11 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [62976];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [62976];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[324];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[324 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[360];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[360 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [75648];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [75648];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[336];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[336 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[384];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[384 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[432];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[432 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[480];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[480 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[528];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[528 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [94080];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [94080];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [24960];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 14 CNs 
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+// Process group with <23 CNs 
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [99072];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [99072];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[264];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[264 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[276];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[276 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[300];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[300 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[312];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[312 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[324];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[324 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [109824];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [109824];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[264];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[264 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[276];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[276 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[300];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[300 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[312];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[312 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[324];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[324 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[336];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[336 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[348];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[348 + i]);
+            p_res++;
+            p_llrRes++;
+}
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z7_R13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z7_R13_AVX2.c
new file mode 100644
index 0000000000..94f64d1fad
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z7_R13_AVX2.c
@@ -0,0 +1,978 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProc_BG1_Z7_R13_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes,  int8_t* llrRes ) {
+        __m256i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m256i* p_llrRes; 
+        __m256i* p_res; 
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [16128];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [16128];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [17664];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [17664];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [19584];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [19584];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [24192];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [24192];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [34944];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [34944];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [44160];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [44160];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [47616];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [47616];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[336];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[336 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[384];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[384 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[432];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[432 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 11 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [62976];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [62976];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[324];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[324 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[360];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[360 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [75648];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [75648];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[336];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[336 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[384];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[384 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[432];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[432 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[480];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[480 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[528];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[528 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [94080];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [94080];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [24960];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 14 CNs 
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+// Process group with <23 CNs 
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [99072];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [99072];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[264];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[264 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[276];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[276 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[300];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[300 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[312];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[312 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[324];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[324 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [109824];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [109824];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[264];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[264 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[276];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[276 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[300];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[300 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[312];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[312 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[324];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[324 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[336];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[336 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[348];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[348 + i]);
+            p_res++;
+            p_llrRes++;
+}
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z80_R13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z80_R13_AVX2.c
new file mode 100644
index 0000000000..931abd13c8
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z80_R13_AVX2.c
@@ -0,0 +1,978 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProc_BG1_Z80_R13_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes,  int8_t* llrRes ) {
+        __m256i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m256i* p_llrRes; 
+        __m256i* p_res; 
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [16128];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [16128];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [17664];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [17664];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [19584];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [19584];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [24192];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [24192];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [34944];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [34944];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [44160];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [44160];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [47616];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [47616];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[336];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[336 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[384];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[384 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[432];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[432 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 11 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [62976];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [62976];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[324];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[324 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[360];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[360 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [75648];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [75648];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[336];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[336 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[384];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[384 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[432];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[432 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[480];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[480 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[528];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[528 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [94080];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [94080];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [24960];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 14 CNs 
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+// Process group with <23 CNs 
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [99072];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [99072];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[264];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[264 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[276];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[276 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[300];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[300 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[312];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[312 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[324];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[324 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [109824];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [109824];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[264];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[264 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[276];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[276 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[300];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[300 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[312];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[312 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[324];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[324 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[336];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[336 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[348];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[348 + i]);
+            p_res++;
+            p_llrRes++;
+}
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z88_R13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z88_R13_AVX2.c
new file mode 100644
index 0000000000..4b88d79461
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z88_R13_AVX2.c
@@ -0,0 +1,978 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProc_BG1_Z88_R13_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes,  int8_t* llrRes ) {
+        __m256i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m256i* p_llrRes; 
+        __m256i* p_res; 
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [16128];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [16128];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [17664];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [17664];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [19584];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [19584];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [24192];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [24192];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [34944];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [34944];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [44160];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [44160];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [47616];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [47616];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[336];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[336 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[384];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[384 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[432];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[432 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 11 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [62976];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [62976];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[324];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[324 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[360];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[360 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [75648];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [75648];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[336];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[336 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[384];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[384 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[432];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[432 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[480];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[480 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[528];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[528 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [94080];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [94080];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [24960];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 14 CNs 
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+// Process group with <23 CNs 
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [99072];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [99072];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[264];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[264 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[276];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[276 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[300];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[300 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[312];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[312 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[324];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[324 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [109824];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [109824];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[264];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[264 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[276];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[276 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[300];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[300 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[312];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[312 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[324];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[324 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[336];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[336 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[348];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[348 + i]);
+            p_res++;
+            p_llrRes++;
+}
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z8_R13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z8_R13_AVX2.c
new file mode 100644
index 0000000000..83032f55a1
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z8_R13_AVX2.c
@@ -0,0 +1,978 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProc_BG1_Z8_R13_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes,  int8_t* llrRes ) {
+        __m256i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m256i* p_llrRes; 
+        __m256i* p_res; 
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [16128];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [16128];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [17664];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [17664];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [19584];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [19584];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [24192];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [24192];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [34944];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [34944];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [44160];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [44160];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [47616];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [47616];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[336];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[336 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[384];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[384 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[432];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[432 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 11 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [62976];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [62976];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[324];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[324 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[360];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[360 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [75648];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [75648];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[336];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[336 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[384];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[384 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[432];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[432 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[480];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[480 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[528];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[528 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [94080];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [94080];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [24960];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 14 CNs 
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+// Process group with <23 CNs 
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [99072];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [99072];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[264];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[264 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[276];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[276 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[300];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[300 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[312];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[312 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[324];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[324 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [109824];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [109824];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[264];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[264 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[276];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[276 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[300];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[300 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[312];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[312 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[324];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[324 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[336];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[336 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[348];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[348 + i]);
+            p_res++;
+            p_llrRes++;
+}
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z96_R13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z96_R13_AVX2.c
new file mode 100644
index 0000000000..649308b2a1
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z96_R13_AVX2.c
@@ -0,0 +1,978 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProc_BG1_Z96_R13_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes,  int8_t* llrRes ) {
+        __m256i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m256i* p_llrRes; 
+        __m256i* p_res; 
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [16128];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [16128];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [17664];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [17664];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [19584];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [19584];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [24192];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [24192];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [34944];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [34944];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [44160];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [44160];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [47616];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [47616];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[336];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[336 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[384];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[384 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[432];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[432 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 11 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [62976];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [62976];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[324];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[324 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[360];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[360 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [75648];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [75648];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[336];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[336 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[384];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[384 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[432];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[432 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[480];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[480 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[528];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[528 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [94080];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [94080];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [24960];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 14 CNs 
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+// Process group with <23 CNs 
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [99072];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [99072];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[264];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[264 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[276];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[276 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[300];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[300 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[312];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[312 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[324];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[324 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [109824];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [109824];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[264];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[264 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[276];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[276 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[300];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[300 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[312];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[312 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[324];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[324 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[336];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[336 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[348];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[348 + i]);
+            p_res++;
+            p_llrRes++;
+}
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z9_R13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z9_R13_AVX2.c
new file mode 100644
index 0000000000..e16be52cea
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG1_Z9_R13_AVX2.c
@@ -0,0 +1,978 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProc_BG1_Z9_R13_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes,  int8_t* llrRes ) {
+        __m256i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m256i* p_llrRes; 
+        __m256i* p_res; 
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [16128];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [16128];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [17664];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [17664];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [19584];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [19584];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [16896];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [24192];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [24192];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [34944];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [34944];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [44160];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [44160];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [20352];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [47616];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [47616];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[336];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[336 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[384];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[384 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[432];
+            p_llrRes = (__m256i*) &llrRes  [20736];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[432 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 11 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [62976];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [62976];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[324];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[324 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[360];
+            p_llrRes = (__m256i*) &llrRes  [22272];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[360 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [75648];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [75648];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[336];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[336 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[384];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[384 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[432];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[432 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[480];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[480 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[528];
+            p_llrRes = (__m256i*) &llrRes  [23424];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[528 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [94080];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [94080];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [24960];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 14 CNs 
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+// Process group with <23 CNs 
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [99072];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [99072];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[264];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[264 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[276];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[276 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[300];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[300 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[312];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[312 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[324];
+            p_llrRes = (__m256i*) &llrRes  [25344];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[324 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [109824];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [109824];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[264];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[264 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[276];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[276 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[288];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[288 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[300];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[300 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[312];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[312 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[324];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[324 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[336];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[336 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[348];
+            p_llrRes = (__m256i*) &llrRes  [25728];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[348 + i]);
+            p_res++;
+            p_llrRes++;
+}
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z104_R15_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z104_R15_AVX2.c
new file mode 100644
index 0000000000..6de8a73cfe
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z104_R15_AVX2.c
@@ -0,0 +1,992 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProc_BG2_Z104_R15_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes,  int8_t* llrRes  ) {
+        __m256i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m256i* p_llrRes; 
+        __m256i* p_res; 
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [14592];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [14592];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [18432];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [18432];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [20736];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [20736];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [23424];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [23424];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [26496];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [26496];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [33408];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [33408];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 11 CNs 
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [37248];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [37248];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [41856];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [41856];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [18048];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 14 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [46848];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [46848];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [52224];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [52224];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [58368];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [58368];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 23 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [66816];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [66816];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[264];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[264 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z10_R15_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z10_R15_AVX2.c
new file mode 100644
index 0000000000..da7eecd7c9
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z10_R15_AVX2.c
@@ -0,0 +1,992 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProc_BG2_Z10_R15_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes,  int8_t* llrRes  ) {
+        __m256i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m256i* p_llrRes; 
+        __m256i* p_res; 
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [14592];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [14592];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [18432];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [18432];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [20736];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [20736];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [23424];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [23424];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [26496];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [26496];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [33408];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [33408];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 11 CNs 
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [37248];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [37248];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [41856];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [41856];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [18048];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 14 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [46848];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [46848];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [52224];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [52224];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [58368];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [58368];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 23 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [66816];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [66816];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[264];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[264 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z112_R15_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z112_R15_AVX2.c
new file mode 100644
index 0000000000..3613096240
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z112_R15_AVX2.c
@@ -0,0 +1,992 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProc_BG2_Z112_R15_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes,  int8_t* llrRes  ) {
+        __m256i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m256i* p_llrRes; 
+        __m256i* p_res; 
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [14592];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [14592];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [18432];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [18432];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [20736];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [20736];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [23424];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [23424];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [26496];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [26496];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [33408];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [33408];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 11 CNs 
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [37248];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [37248];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [41856];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [41856];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [18048];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 14 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [46848];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [46848];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [52224];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [52224];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [58368];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [58368];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 23 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [66816];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [66816];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[264];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[264 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z11_R15_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z11_R15_AVX2.c
new file mode 100644
index 0000000000..ce583e8a49
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z11_R15_AVX2.c
@@ -0,0 +1,992 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProc_BG2_Z11_R15_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes,  int8_t* llrRes  ) {
+        __m256i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m256i* p_llrRes; 
+        __m256i* p_res; 
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [14592];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [14592];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [18432];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [18432];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [20736];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [20736];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [23424];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [23424];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [26496];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [26496];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [33408];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [33408];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 11 CNs 
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [37248];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [37248];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [41856];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [41856];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [18048];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 14 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [46848];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [46848];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [52224];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [52224];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [58368];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [58368];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 23 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [66816];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [66816];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[264];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[264 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z120_R15_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z120_R15_AVX2.c
new file mode 100644
index 0000000000..9567913d4c
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z120_R15_AVX2.c
@@ -0,0 +1,992 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProc_BG2_Z120_R15_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes,  int8_t* llrRes  ) {
+        __m256i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m256i* p_llrRes; 
+        __m256i* p_res; 
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [14592];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [14592];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [18432];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [18432];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [20736];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [20736];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [23424];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [23424];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [26496];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [26496];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [33408];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [33408];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 11 CNs 
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [37248];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [37248];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [41856];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [41856];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [18048];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 14 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [46848];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [46848];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [52224];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [52224];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [58368];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [58368];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 23 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [66816];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [66816];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[264];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[264 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z128_R15_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z128_R15_AVX2.c
new file mode 100644
index 0000000000..3dcd56e4b2
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z128_R15_AVX2.c
@@ -0,0 +1,992 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProc_BG2_Z128_R15_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes,  int8_t* llrRes  ) {
+        __m256i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m256i* p_llrRes; 
+        __m256i* p_res; 
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [14592];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [14592];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [18432];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [18432];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [20736];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [20736];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [23424];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [23424];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [26496];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [26496];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [33408];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [33408];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 11 CNs 
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [37248];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [37248];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [41856];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [41856];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [18048];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 14 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [46848];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [46848];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [52224];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [52224];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [58368];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [58368];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 23 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [66816];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [66816];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[264];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[264 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z12_R15_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z12_R15_AVX2.c
new file mode 100644
index 0000000000..a1e7eef92d
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z12_R15_AVX2.c
@@ -0,0 +1,992 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProc_BG2_Z12_R15_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes,  int8_t* llrRes  ) {
+        __m256i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m256i* p_llrRes; 
+        __m256i* p_res; 
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [14592];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [14592];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [18432];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [18432];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [20736];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [20736];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [23424];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [23424];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [26496];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [26496];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [33408];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [33408];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 11 CNs 
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [37248];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [37248];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [41856];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [41856];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [18048];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 14 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [46848];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [46848];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [52224];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [52224];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [58368];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [58368];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 23 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [66816];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [66816];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[264];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[264 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z13_R15_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z13_R15_AVX2.c
new file mode 100644
index 0000000000..c604b9c9fc
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z13_R15_AVX2.c
@@ -0,0 +1,992 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProc_BG2_Z13_R15_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes,  int8_t* llrRes  ) {
+        __m256i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m256i* p_llrRes; 
+        __m256i* p_res; 
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [14592];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [14592];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [18432];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [18432];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [20736];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [20736];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [23424];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [23424];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [26496];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [26496];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [33408];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [33408];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 11 CNs 
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [37248];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [37248];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [41856];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [41856];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [18048];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 14 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [46848];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [46848];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [52224];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [52224];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [58368];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [58368];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 23 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [66816];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [66816];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[264];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[264 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z144_R15_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z144_R15_AVX2.c
new file mode 100644
index 0000000000..3a6d5fad9b
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z144_R15_AVX2.c
@@ -0,0 +1,992 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProc_BG2_Z144_R15_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes,  int8_t* llrRes  ) {
+        __m256i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m256i* p_llrRes; 
+        __m256i* p_res; 
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [14592];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [14592];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [18432];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [18432];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [20736];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [20736];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [23424];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [23424];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [26496];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [26496];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [33408];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [33408];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 11 CNs 
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [37248];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [37248];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [41856];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [41856];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [18048];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 14 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [46848];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [46848];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [52224];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [52224];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [58368];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [58368];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 23 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [66816];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [66816];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[264];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[264 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z14_R15_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z14_R15_AVX2.c
new file mode 100644
index 0000000000..0a68dcc192
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z14_R15_AVX2.c
@@ -0,0 +1,992 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProc_BG2_Z14_R15_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes,  int8_t* llrRes  ) {
+        __m256i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m256i* p_llrRes; 
+        __m256i* p_res; 
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [14592];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [14592];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [18432];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [18432];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [20736];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [20736];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [23424];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [23424];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [26496];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [26496];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [33408];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [33408];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 11 CNs 
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [37248];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [37248];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [41856];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [41856];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [18048];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 14 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [46848];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [46848];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [52224];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [52224];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [58368];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [58368];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 23 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [66816];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [66816];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[264];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[264 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z15_R15_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z15_R15_AVX2.c
new file mode 100644
index 0000000000..5e1b4e5247
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z15_R15_AVX2.c
@@ -0,0 +1,992 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProc_BG2_Z15_R15_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes,  int8_t* llrRes  ) {
+        __m256i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m256i* p_llrRes; 
+        __m256i* p_res; 
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [14592];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [14592];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [18432];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [18432];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [20736];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [20736];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [23424];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [23424];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [26496];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [26496];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [33408];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [33408];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 11 CNs 
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [37248];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [37248];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [41856];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [41856];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [18048];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 14 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [46848];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [46848];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [52224];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [52224];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [58368];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [58368];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 23 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [66816];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [66816];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[264];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[264 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z160_R15_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z160_R15_AVX2.c
new file mode 100644
index 0000000000..301752c898
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z160_R15_AVX2.c
@@ -0,0 +1,992 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProc_BG2_Z160_R15_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes,  int8_t* llrRes  ) {
+        __m256i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m256i* p_llrRes; 
+        __m256i* p_res; 
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [14592];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [14592];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [18432];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [18432];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [20736];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [20736];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [23424];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [23424];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [26496];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [26496];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [33408];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [33408];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 11 CNs 
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [37248];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [37248];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [41856];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [41856];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [18048];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 14 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [46848];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [46848];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [52224];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [52224];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [58368];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [58368];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 23 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [66816];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [66816];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[264];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[264 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z16_R15_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z16_R15_AVX2.c
new file mode 100644
index 0000000000..2ff4596dec
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z16_R15_AVX2.c
@@ -0,0 +1,992 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProc_BG2_Z16_R15_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes,  int8_t* llrRes  ) {
+        __m256i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m256i* p_llrRes; 
+        __m256i* p_res; 
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [14592];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [14592];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [18432];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [18432];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [20736];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [20736];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [23424];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [23424];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [26496];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [26496];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [33408];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [33408];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 11 CNs 
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [37248];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [37248];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [41856];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [41856];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [18048];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 14 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [46848];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [46848];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [52224];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [52224];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [58368];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [58368];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 23 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [66816];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [66816];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[264];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[264 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z176_R15_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z176_R15_AVX2.c
new file mode 100644
index 0000000000..25d44d65dd
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z176_R15_AVX2.c
@@ -0,0 +1,992 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProc_BG2_Z176_R15_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes,  int8_t* llrRes  ) {
+        __m256i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m256i* p_llrRes; 
+        __m256i* p_res; 
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [14592];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [14592];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [18432];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [18432];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [20736];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [20736];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [23424];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [23424];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [26496];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [26496];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [33408];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [33408];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 11 CNs 
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [37248];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [37248];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [41856];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [41856];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [18048];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 14 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [46848];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [46848];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [52224];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [52224];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [58368];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [58368];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 23 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [66816];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [66816];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[264];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[264 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z18_R15_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z18_R15_AVX2.c
new file mode 100644
index 0000000000..d035375329
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z18_R15_AVX2.c
@@ -0,0 +1,992 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProc_BG2_Z18_R15_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes,  int8_t* llrRes  ) {
+        __m256i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m256i* p_llrRes; 
+        __m256i* p_res; 
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [14592];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [14592];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [18432];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [18432];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [20736];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [20736];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [23424];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [23424];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [26496];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [26496];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [33408];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [33408];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 11 CNs 
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [37248];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [37248];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [41856];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [41856];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [18048];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 14 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [46848];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [46848];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [52224];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [52224];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [58368];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [58368];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 23 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [66816];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [66816];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[264];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[264 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z192_R15_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z192_R15_AVX2.c
new file mode 100644
index 0000000000..fe808f0262
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z192_R15_AVX2.c
@@ -0,0 +1,992 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProc_BG2_Z192_R15_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes,  int8_t* llrRes  ) {
+        __m256i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m256i* p_llrRes; 
+        __m256i* p_res; 
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [14592];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [14592];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [18432];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [18432];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [20736];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [20736];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [23424];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [23424];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [26496];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [26496];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [33408];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [33408];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 11 CNs 
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [37248];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [37248];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [41856];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [41856];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [18048];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 14 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [46848];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [46848];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [52224];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [52224];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [58368];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [58368];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 23 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [66816];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [66816];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[264];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[264 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z208_R15_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z208_R15_AVX2.c
new file mode 100644
index 0000000000..b80ad2550c
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z208_R15_AVX2.c
@@ -0,0 +1,992 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProc_BG2_Z208_R15_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes,  int8_t* llrRes  ) {
+        __m256i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m256i* p_llrRes; 
+        __m256i* p_res; 
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [14592];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [14592];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<13;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<13;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<13;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<13;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<13;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [18432];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [18432];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [20736];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [20736];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [23424];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [23424];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [26496];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [26496];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<13;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<13;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<13;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<13;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<13;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<13;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<13;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<13;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<13;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [33408];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [33408];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 11 CNs 
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [37248];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [37248];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [41856];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [41856];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [18048];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 14 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [46848];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [46848];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [52224];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [52224];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [58368];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [58368];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 23 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [66816];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [66816];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[264];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[264 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z20_R15_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z20_R15_AVX2.c
new file mode 100644
index 0000000000..bea168af3c
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z20_R15_AVX2.c
@@ -0,0 +1,992 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProc_BG2_Z20_R15_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes,  int8_t* llrRes  ) {
+        __m256i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m256i* p_llrRes; 
+        __m256i* p_res; 
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [14592];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [14592];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [18432];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [18432];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [20736];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [20736];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [23424];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [23424];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [26496];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [26496];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [33408];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [33408];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 11 CNs 
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [37248];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [37248];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [41856];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [41856];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [18048];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 14 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [46848];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [46848];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [52224];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [52224];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [58368];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [58368];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 23 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [66816];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [66816];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[264];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[264 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z224_R15_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z224_R15_AVX2.c
new file mode 100644
index 0000000000..6a897f6a58
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z224_R15_AVX2.c
@@ -0,0 +1,992 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProc_BG2_Z224_R15_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes,  int8_t* llrRes  ) {
+        __m256i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m256i* p_llrRes; 
+        __m256i* p_res; 
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [14592];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [14592];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<14;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<14;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<14;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<14;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<14;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [18432];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [18432];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [20736];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [20736];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [23424];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [23424];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [26496];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [26496];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<14;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<14;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<14;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<14;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<14;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<14;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<14;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<14;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<14;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [33408];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [33408];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 11 CNs 
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [37248];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [37248];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [41856];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [41856];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [18048];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 14 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [46848];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [46848];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [52224];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [52224];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [58368];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [58368];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 23 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [66816];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [66816];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[264];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<7;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[264 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z22_R15_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z22_R15_AVX2.c
new file mode 100644
index 0000000000..1686f075cd
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z22_R15_AVX2.c
@@ -0,0 +1,992 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProc_BG2_Z22_R15_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes,  int8_t* llrRes  ) {
+        __m256i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m256i* p_llrRes; 
+        __m256i* p_res; 
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [14592];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [14592];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [18432];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [18432];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [20736];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [20736];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [23424];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [23424];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [26496];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [26496];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [33408];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [33408];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 11 CNs 
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [37248];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [37248];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [41856];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [41856];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [18048];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 14 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [46848];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [46848];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [52224];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [52224];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [58368];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [58368];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 23 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [66816];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [66816];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[264];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[264 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z240_R15_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z240_R15_AVX2.c
new file mode 100644
index 0000000000..ff3f02c22c
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z240_R15_AVX2.c
@@ -0,0 +1,992 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProc_BG2_Z240_R15_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes,  int8_t* llrRes  ) {
+        __m256i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m256i* p_llrRes; 
+        __m256i* p_res; 
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [14592];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [14592];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<15;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<15;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<15;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<15;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<15;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [18432];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [18432];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [20736];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [20736];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [23424];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [23424];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [26496];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [26496];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<15;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<15;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<15;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<15;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<15;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<15;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<15;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<15;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<15;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [33408];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [33408];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 11 CNs 
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [37248];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [37248];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [41856];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [41856];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [18048];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 14 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [46848];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [46848];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [52224];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [52224];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [58368];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [58368];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 23 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [66816];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [66816];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[264];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[264 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z24_R15_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z24_R15_AVX2.c
new file mode 100644
index 0000000000..3a824bf742
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z24_R15_AVX2.c
@@ -0,0 +1,992 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProc_BG2_Z24_R15_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes,  int8_t* llrRes  ) {
+        __m256i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m256i* p_llrRes; 
+        __m256i* p_res; 
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [14592];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [14592];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [18432];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [18432];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [20736];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [20736];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [23424];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [23424];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [26496];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [26496];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [33408];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [33408];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 11 CNs 
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [37248];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [37248];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [41856];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [41856];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [18048];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 14 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [46848];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [46848];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [52224];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [52224];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [58368];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [58368];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 23 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [66816];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [66816];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[264];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[264 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z256_R15_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z256_R15_AVX2.c
new file mode 100644
index 0000000000..1d251bfd7e
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z256_R15_AVX2.c
@@ -0,0 +1,992 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProc_BG2_Z256_R15_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes,  int8_t* llrRes  ) {
+        __m256i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m256i* p_llrRes; 
+        __m256i* p_res; 
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [14592];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [14592];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<16;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<16;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<16;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<16;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<16;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [18432];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [18432];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [20736];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [20736];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [23424];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [23424];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [26496];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [26496];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<16;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<16;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<16;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<16;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<16;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<16;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<16;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<16;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<16;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [33408];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [33408];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 11 CNs 
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [37248];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [37248];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [41856];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [41856];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [18048];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 14 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [46848];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [46848];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [52224];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [52224];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [58368];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [58368];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 23 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [66816];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [66816];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[264];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<8;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[264 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z26_R15_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z26_R15_AVX2.c
new file mode 100644
index 0000000000..9c01cb69a0
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z26_R15_AVX2.c
@@ -0,0 +1,992 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProc_BG2_Z26_R15_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes,  int8_t* llrRes  ) {
+        __m256i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m256i* p_llrRes; 
+        __m256i* p_res; 
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [14592];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [14592];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [18432];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [18432];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [20736];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [20736];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [23424];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [23424];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [26496];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [26496];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [33408];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [33408];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 11 CNs 
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [37248];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [37248];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [41856];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [41856];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [18048];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 14 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [46848];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [46848];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [52224];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [52224];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [58368];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [58368];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 23 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [66816];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [66816];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[264];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[264 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z288_R15_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z288_R15_AVX2.c
new file mode 100644
index 0000000000..c48b6023d6
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z288_R15_AVX2.c
@@ -0,0 +1,992 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProc_BG2_Z288_R15_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes,  int8_t* llrRes  ) {
+        __m256i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m256i* p_llrRes; 
+        __m256i* p_res; 
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [14592];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [14592];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<18;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<18;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<18;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<18;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<18;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [18432];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [18432];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [20736];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [20736];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [23424];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [23424];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [26496];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [26496];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<18;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<18;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<18;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<18;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<18;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<18;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<18;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<18;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<18;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [33408];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [33408];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 11 CNs 
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [37248];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [37248];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [41856];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [41856];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [18048];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 14 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [46848];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [46848];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [52224];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [52224];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [58368];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [58368];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 23 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [66816];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [66816];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[264];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<9;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[264 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z28_R15_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z28_R15_AVX2.c
new file mode 100644
index 0000000000..4b02344ea4
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z28_R15_AVX2.c
@@ -0,0 +1,992 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProc_BG2_Z28_R15_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes,  int8_t* llrRes  ) {
+        __m256i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m256i* p_llrRes; 
+        __m256i* p_res; 
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [14592];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [14592];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [18432];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [18432];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [20736];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [20736];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [23424];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [23424];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [26496];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [26496];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [33408];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [33408];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 11 CNs 
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [37248];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [37248];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [41856];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [41856];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [18048];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 14 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [46848];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [46848];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [52224];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [52224];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [58368];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [58368];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 23 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [66816];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [66816];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[264];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[264 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z2_R15_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z2_R15_AVX2.c
new file mode 100644
index 0000000000..81694205f4
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z2_R15_AVX2.c
@@ -0,0 +1,992 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProc_BG2_Z2_R15_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes,  int8_t* llrRes  ) {
+        __m256i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m256i* p_llrRes; 
+        __m256i* p_res; 
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [14592];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [14592];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [18432];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [18432];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [20736];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [20736];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [23424];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [23424];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [26496];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [26496];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [33408];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [33408];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 11 CNs 
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [37248];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [37248];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [41856];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [41856];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [18048];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 14 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [46848];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [46848];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [52224];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [52224];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [58368];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [58368];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 23 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [66816];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [66816];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[264];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[264 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z30_R15_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z30_R15_AVX2.c
new file mode 100644
index 0000000000..1ca19efbea
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z30_R15_AVX2.c
@@ -0,0 +1,992 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProc_BG2_Z30_R15_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes,  int8_t* llrRes  ) {
+        __m256i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m256i* p_llrRes; 
+        __m256i* p_res; 
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [14592];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [14592];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [18432];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [18432];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [20736];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [20736];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [23424];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [23424];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [26496];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [26496];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [33408];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [33408];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 11 CNs 
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [37248];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [37248];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [41856];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [41856];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [18048];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 14 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [46848];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [46848];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [52224];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [52224];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [58368];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [58368];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 23 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [66816];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [66816];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[264];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[264 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z320_R15_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z320_R15_AVX2.c
new file mode 100644
index 0000000000..cb56abe439
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z320_R15_AVX2.c
@@ -0,0 +1,992 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProc_BG2_Z320_R15_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes,  int8_t* llrRes  ) {
+        __m256i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m256i* p_llrRes; 
+        __m256i* p_res; 
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [14592];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [14592];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<20;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<20;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<20;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<20;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<20;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [18432];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [18432];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [20736];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [20736];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [23424];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [23424];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [26496];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [26496];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<20;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<20;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<20;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<20;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<20;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<20;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<20;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<20;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<20;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [33408];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [33408];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 11 CNs 
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [37248];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [37248];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [41856];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [41856];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [18048];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 14 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [46848];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [46848];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [52224];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [52224];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [58368];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [58368];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 23 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [66816];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [66816];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[264];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<10;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[264 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z32_R15_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z32_R15_AVX2.c
new file mode 100644
index 0000000000..d03e2e943e
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z32_R15_AVX2.c
@@ -0,0 +1,992 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProc_BG2_Z32_R15_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes,  int8_t* llrRes  ) {
+        __m256i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m256i* p_llrRes; 
+        __m256i* p_res; 
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [14592];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [14592];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [18432];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [18432];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [20736];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [20736];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [23424];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [23424];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [26496];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [26496];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [33408];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [33408];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 11 CNs 
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [37248];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [37248];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [41856];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [41856];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [18048];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 14 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [46848];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [46848];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [52224];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [52224];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [58368];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [58368];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 23 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [66816];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [66816];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[264];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[264 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z352_R15_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z352_R15_AVX2.c
new file mode 100644
index 0000000000..6be4e10dd8
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z352_R15_AVX2.c
@@ -0,0 +1,992 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProc_BG2_Z352_R15_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes,  int8_t* llrRes  ) {
+        __m256i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m256i* p_llrRes; 
+        __m256i* p_res; 
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [14592];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [14592];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<22;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<22;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<22;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<22;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<22;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [18432];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [18432];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [20736];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [20736];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [23424];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [23424];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [26496];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [26496];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<22;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<22;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<22;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<22;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<22;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<22;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<22;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<22;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<22;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [33408];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [33408];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 11 CNs 
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [37248];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [37248];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [41856];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [41856];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [18048];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 14 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [46848];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [46848];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [52224];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [52224];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [58368];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [58368];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 23 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [66816];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [66816];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[264];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<11;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[264 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z36_R15_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z36_R15_AVX2.c
new file mode 100644
index 0000000000..3e447f3a1a
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z36_R15_AVX2.c
@@ -0,0 +1,992 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProc_BG2_Z36_R15_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes,  int8_t* llrRes  ) {
+        __m256i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m256i* p_llrRes; 
+        __m256i* p_res; 
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [14592];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [14592];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [18432];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [18432];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [20736];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [20736];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [23424];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [23424];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [26496];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [26496];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [33408];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [33408];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 11 CNs 
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [37248];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [37248];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [41856];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [41856];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [18048];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 14 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [46848];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [46848];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [52224];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [52224];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [58368];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [58368];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 23 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [66816];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [66816];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[264];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[264 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z384_R15_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z384_R15_AVX2.c
new file mode 100644
index 0000000000..2ac44f6c53
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z384_R15_AVX2.c
@@ -0,0 +1,992 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProc_BG2_Z384_R15_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes,  int8_t* llrRes  ) {
+        __m256i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m256i* p_llrRes; 
+        __m256i* p_res; 
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [14592];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [14592];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<24;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<24;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<24;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<24;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<24;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [18432];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [18432];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [20736];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [20736];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [23424];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [23424];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [26496];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [26496];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<24;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<24;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<24;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<24;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<24;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<24;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<24;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<24;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<24;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [33408];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [33408];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 11 CNs 
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [37248];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [37248];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [41856];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [41856];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [18048];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 14 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [46848];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [46848];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [52224];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [52224];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [58368];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [58368];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 23 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [66816];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [66816];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[264];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<12;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[264 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z3_R15_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z3_R15_AVX2.c
new file mode 100644
index 0000000000..3b645790d4
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z3_R15_AVX2.c
@@ -0,0 +1,992 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProc_BG2_Z3_R15_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes,  int8_t* llrRes  ) {
+        __m256i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m256i* p_llrRes; 
+        __m256i* p_res; 
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [14592];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [14592];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [18432];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [18432];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [20736];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [20736];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [23424];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [23424];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [26496];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [26496];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [33408];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [33408];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 11 CNs 
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [37248];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [37248];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [41856];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [41856];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [18048];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 14 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [46848];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [46848];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [52224];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [52224];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [58368];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [58368];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 23 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [66816];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [66816];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[264];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[264 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z40_R15_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z40_R15_AVX2.c
new file mode 100644
index 0000000000..a9eb5dbb00
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z40_R15_AVX2.c
@@ -0,0 +1,992 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProc_BG2_Z40_R15_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes,  int8_t* llrRes  ) {
+        __m256i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m256i* p_llrRes; 
+        __m256i* p_res; 
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [14592];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [14592];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [18432];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [18432];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [20736];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [20736];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [23424];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [23424];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [26496];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [26496];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [33408];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [33408];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 11 CNs 
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [37248];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [37248];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [41856];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [41856];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [18048];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 14 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [46848];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [46848];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [52224];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [52224];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [58368];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [58368];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 23 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [66816];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [66816];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[264];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[264 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z44_R15_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z44_R15_AVX2.c
new file mode 100644
index 0000000000..a6613ef66c
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z44_R15_AVX2.c
@@ -0,0 +1,992 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProc_BG2_Z44_R15_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes,  int8_t* llrRes  ) {
+        __m256i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m256i* p_llrRes; 
+        __m256i* p_res; 
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [14592];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [14592];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [18432];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [18432];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [20736];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [20736];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [23424];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [23424];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [26496];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [26496];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [33408];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [33408];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 11 CNs 
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [37248];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [37248];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [41856];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [41856];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [18048];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 14 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [46848];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [46848];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [52224];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [52224];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [58368];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [58368];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 23 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [66816];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [66816];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[264];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[264 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z48_R15_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z48_R15_AVX2.c
new file mode 100644
index 0000000000..d2a7c80bb0
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z48_R15_AVX2.c
@@ -0,0 +1,992 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProc_BG2_Z48_R15_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes,  int8_t* llrRes  ) {
+        __m256i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m256i* p_llrRes; 
+        __m256i* p_res; 
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [14592];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [14592];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [18432];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [18432];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [20736];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [20736];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [23424];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [23424];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [26496];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [26496];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [33408];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [33408];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 11 CNs 
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [37248];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [37248];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [41856];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [41856];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [18048];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 14 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [46848];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [46848];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [52224];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [52224];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [58368];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [58368];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 23 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [66816];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [66816];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[264];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[264 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z4_R15_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z4_R15_AVX2.c
new file mode 100644
index 0000000000..ae4f4d922f
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z4_R15_AVX2.c
@@ -0,0 +1,992 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProc_BG2_Z4_R15_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes,  int8_t* llrRes  ) {
+        __m256i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m256i* p_llrRes; 
+        __m256i* p_res; 
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [14592];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [14592];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [18432];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [18432];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [20736];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [20736];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [23424];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [23424];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [26496];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [26496];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [33408];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [33408];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 11 CNs 
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [37248];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [37248];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [41856];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [41856];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [18048];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 14 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [46848];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [46848];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [52224];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [52224];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [58368];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [58368];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 23 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [66816];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [66816];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[264];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[264 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z52_R15_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z52_R15_AVX2.c
new file mode 100644
index 0000000000..3efa774165
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z52_R15_AVX2.c
@@ -0,0 +1,992 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProc_BG2_Z52_R15_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes,  int8_t* llrRes  ) {
+        __m256i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m256i* p_llrRes; 
+        __m256i* p_res; 
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [14592];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [14592];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [18432];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [18432];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [20736];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [20736];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [23424];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [23424];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [26496];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [26496];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [33408];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [33408];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 11 CNs 
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [37248];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [37248];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [41856];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [41856];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [18048];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 14 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [46848];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [46848];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [52224];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [52224];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [58368];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [58368];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 23 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [66816];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [66816];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[264];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[264 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z56_R15_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z56_R15_AVX2.c
new file mode 100644
index 0000000000..f61d8ea7d7
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z56_R15_AVX2.c
@@ -0,0 +1,992 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProc_BG2_Z56_R15_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes,  int8_t* llrRes  ) {
+        __m256i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m256i* p_llrRes; 
+        __m256i* p_res; 
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [14592];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [14592];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [18432];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [18432];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [20736];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [20736];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [23424];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [23424];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [26496];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [26496];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [33408];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [33408];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 11 CNs 
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [37248];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [37248];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [41856];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [41856];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [18048];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 14 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [46848];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [46848];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [52224];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [52224];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [58368];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [58368];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 23 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [66816];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [66816];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[264];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[264 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z5_R15_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z5_R15_AVX2.c
new file mode 100644
index 0000000000..6528758122
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z5_R15_AVX2.c
@@ -0,0 +1,992 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProc_BG2_Z5_R15_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes,  int8_t* llrRes  ) {
+        __m256i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m256i* p_llrRes; 
+        __m256i* p_res; 
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [14592];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [14592];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [18432];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [18432];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [20736];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [20736];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [23424];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [23424];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [26496];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [26496];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [33408];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [33408];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 11 CNs 
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [37248];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [37248];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [41856];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [41856];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [18048];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 14 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [46848];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [46848];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [52224];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [52224];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [58368];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [58368];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 23 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [66816];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [66816];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[264];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[264 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z60_R15_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z60_R15_AVX2.c
new file mode 100644
index 0000000000..d7a3be2173
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z60_R15_AVX2.c
@@ -0,0 +1,992 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProc_BG2_Z60_R15_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes,  int8_t* llrRes  ) {
+        __m256i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m256i* p_llrRes; 
+        __m256i* p_res; 
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [14592];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [14592];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [18432];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [18432];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [20736];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [20736];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [23424];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [23424];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [26496];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [26496];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [33408];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [33408];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 11 CNs 
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [37248];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [37248];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [41856];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [41856];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [18048];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 14 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [46848];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [46848];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [52224];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [52224];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [58368];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [58368];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 23 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [66816];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [66816];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[264];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[264 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z64_R15_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z64_R15_AVX2.c
new file mode 100644
index 0000000000..58457add44
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z64_R15_AVX2.c
@@ -0,0 +1,992 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProc_BG2_Z64_R15_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes,  int8_t* llrRes  ) {
+        __m256i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m256i* p_llrRes; 
+        __m256i* p_res; 
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [14592];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [14592];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [18432];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [18432];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [20736];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [20736];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [23424];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [23424];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [26496];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [26496];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<4;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [33408];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [33408];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 11 CNs 
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [37248];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [37248];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [41856];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [41856];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [18048];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 14 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [46848];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [46848];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [52224];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [52224];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [58368];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [58368];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 23 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [66816];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [66816];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[264];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<2;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[264 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z6_R15_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z6_R15_AVX2.c
new file mode 100644
index 0000000000..f9c2093489
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z6_R15_AVX2.c
@@ -0,0 +1,992 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProc_BG2_Z6_R15_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes,  int8_t* llrRes  ) {
+        __m256i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m256i* p_llrRes; 
+        __m256i* p_res; 
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [14592];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [14592];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [18432];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [18432];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [20736];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [20736];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [23424];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [23424];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [26496];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [26496];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [33408];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [33408];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 11 CNs 
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [37248];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [37248];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [41856];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [41856];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [18048];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 14 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [46848];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [46848];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [52224];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [52224];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [58368];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [58368];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 23 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [66816];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [66816];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[264];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[264 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z72_R15_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z72_R15_AVX2.c
new file mode 100644
index 0000000000..9d14029acc
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z72_R15_AVX2.c
@@ -0,0 +1,992 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProc_BG2_Z72_R15_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes,  int8_t* llrRes  ) {
+        __m256i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m256i* p_llrRes; 
+        __m256i* p_res; 
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [14592];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [14592];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [18432];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [18432];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [20736];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [20736];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [23424];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [23424];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [26496];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [26496];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [33408];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [33408];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 11 CNs 
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [37248];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [37248];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [41856];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [41856];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [18048];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 14 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [46848];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [46848];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [52224];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [52224];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [58368];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [58368];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 23 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [66816];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [66816];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[264];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[264 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z7_R15_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z7_R15_AVX2.c
new file mode 100644
index 0000000000..188b6a94dd
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z7_R15_AVX2.c
@@ -0,0 +1,992 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProc_BG2_Z7_R15_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes,  int8_t* llrRes  ) {
+        __m256i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m256i* p_llrRes; 
+        __m256i* p_res; 
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [14592];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [14592];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [18432];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [18432];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [20736];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [20736];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [23424];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [23424];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [26496];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [26496];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [33408];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [33408];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 11 CNs 
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [37248];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [37248];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [41856];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [41856];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [18048];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 14 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [46848];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [46848];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [52224];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [52224];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [58368];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [58368];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 23 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [66816];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [66816];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[264];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[264 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z80_R15_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z80_R15_AVX2.c
new file mode 100644
index 0000000000..ac2c167b9a
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z80_R15_AVX2.c
@@ -0,0 +1,992 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProc_BG2_Z80_R15_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes,  int8_t* llrRes  ) {
+        __m256i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m256i* p_llrRes; 
+        __m256i* p_res; 
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [14592];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [14592];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [18432];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [18432];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [20736];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [20736];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [23424];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [23424];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [26496];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [26496];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<5;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [33408];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [33408];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 11 CNs 
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [37248];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [37248];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [41856];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [41856];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [18048];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 14 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [46848];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [46848];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [52224];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [52224];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [58368];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [58368];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 23 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [66816];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [66816];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[264];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[264 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z88_R15_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z88_R15_AVX2.c
new file mode 100644
index 0000000000..4d5ec0740c
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z88_R15_AVX2.c
@@ -0,0 +1,992 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProc_BG2_Z88_R15_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes,  int8_t* llrRes  ) {
+        __m256i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m256i* p_llrRes; 
+        __m256i* p_res; 
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [14592];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [14592];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [18432];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [18432];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [20736];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [20736];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [23424];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [23424];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [26496];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [26496];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [33408];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [33408];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 11 CNs 
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [37248];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [37248];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [41856];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [41856];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [18048];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 14 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [46848];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [46848];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [52224];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [52224];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [58368];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [58368];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 23 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [66816];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [66816];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[264];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[264 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z8_R15_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z8_R15_AVX2.c
new file mode 100644
index 0000000000..f4b84e4509
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z8_R15_AVX2.c
@@ -0,0 +1,992 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProc_BG2_Z8_R15_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes,  int8_t* llrRes  ) {
+        __m256i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m256i* p_llrRes; 
+        __m256i* p_res; 
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [14592];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [14592];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [18432];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [18432];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [20736];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [20736];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [23424];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [23424];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [26496];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [26496];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [33408];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [33408];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 11 CNs 
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [37248];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [37248];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [41856];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [41856];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [18048];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 14 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [46848];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [46848];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [52224];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [52224];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [58368];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [58368];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 23 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [66816];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [66816];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[264];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[264 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z96_R15_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z96_R15_AVX2.c
new file mode 100644
index 0000000000..83a4a54c13
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z96_R15_AVX2.c
@@ -0,0 +1,992 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProc_BG2_Z96_R15_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes,  int8_t* llrRes  ) {
+        __m256i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m256i* p_llrRes; 
+        __m256i* p_res; 
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [14592];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [14592];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [18432];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [18432];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [20736];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [20736];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [23424];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [23424];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [26496];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [26496];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<6;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [33408];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [33408];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 11 CNs 
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [37248];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [37248];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [41856];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [41856];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [18048];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 14 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [46848];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [46848];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [52224];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [52224];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [58368];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [58368];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 23 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [66816];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [66816];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[264];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<3;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[264 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z9_R15_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z9_R15_AVX2.c
new file mode 100644
index 0000000000..ed5464778a
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProc/nrLDPC_bnProc_BG2_Z9_R15_AVX2.c
@@ -0,0 +1,992 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProc_BG2_Z9_R15_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes,  int8_t* llrRes  ) {
+        __m256i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m256i* p_llrRes; 
+        __m256i* p_res; 
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [14592];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [14592];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [14592];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [18432];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [18432];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [15360];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [20736];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [20736];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [15744];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [23424];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [23424];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [16128];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [26496];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [26496];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [16512];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [33408];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [33408];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [17280];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 11 CNs 
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [37248];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [37248];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [17664];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [41856];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [41856];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [18048];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 14 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [46848];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [46848];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [18432];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [52224];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [52224];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [18816];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [58368];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [58368];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [19200];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 23 CNs 
+    p_bnProcBuf     = (__m256i*) &bnProcBuf    [66816];
+   p_bnProcBufRes    = (__m256i*) &bnProcBufRes   [66816];
+            p_res = &p_bnProcBufRes[0];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[0 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[12];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[12 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[24];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[24 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[36];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[36 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[48];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[48 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[60];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[60 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[72];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[72 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[84];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[84 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[96];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[96 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[108];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[108 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[120];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[120 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[132];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[132 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[144];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[144 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[156];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[156 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[168];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[168 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[180];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[180 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[192];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[192 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[204];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[204 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[216];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[216 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[228];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[228 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[240];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[240 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[252];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[252 + i]);
+            p_res++;
+            p_llrRes++;
+}
+            p_res = &p_bnProcBufRes[264];
+            p_llrRes = (__m256i*) &llrRes  [19584];
+            for (int i=0;i<1;i++) {
+            *p_res = _mm256_subs_epi8(*p_llrRes, p_bnProcBuf[264 + i]);
+            p_res++;
+            p_llrRes++;
+}
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z104_R13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z104_R13_AVX2.c
new file mode 100644
index 0000000000..94b217187d
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z104_R13_AVX2.c
@@ -0,0 +1,749 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProcPc_BG1_Z104_R13_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes,  int8_t* llrRes ,  int8_t* llrProcBuf ) {
+   __m256i ymm0, ymm1, ymmRes0, ymmRes1;  
+        __m128i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m128i* p_llrProcBuf;
+        __m256i* p_llrProcBuf256; 
+        __m256i* p_llrRes; 
+// Process group with 1 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [0];
+    p_bnProcBufRes  = (__m256i*) &bnProcBufRes [0];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [0];
+    p_llrProcBuf256 = (__m256i*) &llrProcBuf   [0];
+    p_llrRes        = (__m256i*) &llrRes       [0];
+            for (int i=0,j=0;i<137;i++,j+=2) {
+             p_bnProcBufRes[i] = p_llrProcBuf256[i];
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j+1]);
+           ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j+1]);
+            ymmRes1 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [16128];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16128];
+    p_llrRes        = (__m256i*) &llrRes       [16128];
+        for (int i=0,j=0;i<4;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [17664];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16512];
+    p_llrRes        = (__m256i*) &llrRes       [16512];
+        for (int i=0,j=0;i<4;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [19584];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16896];
+    p_llrRes        = (__m256i*) &llrRes       [16896];
+        for (int i=0,j=0;i<7;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [24192];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [17664];
+    p_llrRes        = (__m256i*) &llrRes       [17664];
+        for (int i=0,j=0;i<13;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [34944];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [19200];
+    p_llrRes        = (__m256i*) &llrRes       [19200];
+        for (int i=0,j=0;i<10;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [44160];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [20352];
+    p_llrRes        = (__m256i*) &llrRes       [20352];
+        for (int i=0,j=0;i<4;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [47616];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [20736];
+    p_llrRes        = (__m256i*) &llrRes       [20736];
+        for (int i=0,j=0;i<13;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 11 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [62976];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [22272];
+    p_llrRes        = (__m256i*) &llrRes       [22272];
+            for (int i=0,j=0;i<10;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[720 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[720 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [75648];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [23424];
+    p_llrRes        = (__m256i*) &llrRes       [23424];
+            for (int i=0,j=0;i<13;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[960 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[960 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[1056 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[1056 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [94080];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [24960];
+    p_llrRes        = (__m256i*) &llrRes       [24960];
+        for (int i=0,j=0;i<4;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 14 CNs 
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+// Process group with <23 CNs 
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [99072];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [25344];
+    p_llrRes        = (__m256i*) &llrRes       [25344];
+        for (int i=0,j=0;i<4;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [109824];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [25728];
+    p_llrRes        = (__m256i*) &llrRes       [25728];
+        for (int i=0,j=0;i<4;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[696 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[696 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z10_R13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z10_R13_AVX2.c
new file mode 100644
index 0000000000..160bce3117
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z10_R13_AVX2.c
@@ -0,0 +1,749 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProcPc_BG1_Z10_R13_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes,  int8_t* llrRes ,  int8_t* llrProcBuf ) {
+   __m256i ymm0, ymm1, ymmRes0, ymmRes1;  
+        __m128i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m128i* p_llrProcBuf;
+        __m256i* p_llrProcBuf256; 
+        __m256i* p_llrRes; 
+// Process group with 1 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [0];
+    p_bnProcBufRes  = (__m256i*) &bnProcBufRes [0];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [0];
+    p_llrProcBuf256 = (__m256i*) &llrProcBuf   [0];
+    p_llrRes        = (__m256i*) &llrRes       [0];
+            for (int i=0,j=0;i<14;i++,j+=2) {
+             p_bnProcBufRes[i] = p_llrProcBuf256[i];
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j+1]);
+           ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j+1]);
+            ymmRes1 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [16128];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16128];
+    p_llrRes        = (__m256i*) &llrRes       [16128];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [17664];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16512];
+    p_llrRes        = (__m256i*) &llrRes       [16512];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [19584];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16896];
+    p_llrRes        = (__m256i*) &llrRes       [16896];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [24192];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [17664];
+    p_llrRes        = (__m256i*) &llrRes       [17664];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [34944];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [19200];
+    p_llrRes        = (__m256i*) &llrRes       [19200];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [44160];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [20352];
+    p_llrRes        = (__m256i*) &llrRes       [20352];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [47616];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [20736];
+    p_llrRes        = (__m256i*) &llrRes       [20736];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 11 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [62976];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [22272];
+    p_llrRes        = (__m256i*) &llrRes       [22272];
+            for (int i=0,j=0;i<1;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[720 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[720 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [75648];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [23424];
+    p_llrRes        = (__m256i*) &llrRes       [23424];
+            for (int i=0,j=0;i<2;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[960 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[960 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[1056 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[1056 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [94080];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [24960];
+    p_llrRes        = (__m256i*) &llrRes       [24960];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 14 CNs 
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+// Process group with <23 CNs 
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [99072];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [25344];
+    p_llrRes        = (__m256i*) &llrRes       [25344];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [109824];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [25728];
+    p_llrRes        = (__m256i*) &llrRes       [25728];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[696 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[696 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z112_R13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z112_R13_AVX2.c
new file mode 100644
index 0000000000..0e753bfab3
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z112_R13_AVX2.c
@@ -0,0 +1,749 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProcPc_BG1_Z112_R13_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes,  int8_t* llrRes ,  int8_t* llrProcBuf ) {
+   __m256i ymm0, ymm1, ymmRes0, ymmRes1;  
+        __m128i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m128i* p_llrProcBuf;
+        __m256i* p_llrProcBuf256; 
+        __m256i* p_llrRes; 
+// Process group with 1 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [0];
+    p_bnProcBufRes  = (__m256i*) &bnProcBufRes [0];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [0];
+    p_llrProcBuf256 = (__m256i*) &llrProcBuf   [0];
+    p_llrRes        = (__m256i*) &llrRes       [0];
+            for (int i=0,j=0;i<147;i++,j+=2) {
+             p_bnProcBufRes[i] = p_llrProcBuf256[i];
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j+1]);
+           ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j+1]);
+            ymmRes1 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [16128];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16128];
+    p_llrRes        = (__m256i*) &llrRes       [16128];
+        for (int i=0,j=0;i<4;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [17664];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16512];
+    p_llrRes        = (__m256i*) &llrRes       [16512];
+        for (int i=0,j=0;i<4;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [19584];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16896];
+    p_llrRes        = (__m256i*) &llrRes       [16896];
+        for (int i=0,j=0;i<7;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [24192];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [17664];
+    p_llrRes        = (__m256i*) &llrRes       [17664];
+        for (int i=0,j=0;i<14;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [34944];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [19200];
+    p_llrRes        = (__m256i*) &llrRes       [19200];
+        for (int i=0,j=0;i<11;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [44160];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [20352];
+    p_llrRes        = (__m256i*) &llrRes       [20352];
+        for (int i=0,j=0;i<4;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [47616];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [20736];
+    p_llrRes        = (__m256i*) &llrRes       [20736];
+        for (int i=0,j=0;i<14;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 11 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [62976];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [22272];
+    p_llrRes        = (__m256i*) &llrRes       [22272];
+            for (int i=0,j=0;i<11;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[720 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[720 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [75648];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [23424];
+    p_llrRes        = (__m256i*) &llrRes       [23424];
+            for (int i=0,j=0;i<14;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[960 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[960 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[1056 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[1056 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [94080];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [24960];
+    p_llrRes        = (__m256i*) &llrRes       [24960];
+        for (int i=0,j=0;i<4;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 14 CNs 
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+// Process group with <23 CNs 
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [99072];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [25344];
+    p_llrRes        = (__m256i*) &llrRes       [25344];
+        for (int i=0,j=0;i<4;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [109824];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [25728];
+    p_llrRes        = (__m256i*) &llrRes       [25728];
+        for (int i=0,j=0;i<4;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[696 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[696 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z11_R13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z11_R13_AVX2.c
new file mode 100644
index 0000000000..3a16eaa82f
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z11_R13_AVX2.c
@@ -0,0 +1,749 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProcPc_BG1_Z11_R13_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes,  int8_t* llrRes ,  int8_t* llrProcBuf ) {
+   __m256i ymm0, ymm1, ymmRes0, ymmRes1;  
+        __m128i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m128i* p_llrProcBuf;
+        __m256i* p_llrProcBuf256; 
+        __m256i* p_llrRes; 
+// Process group with 1 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [0];
+    p_bnProcBufRes  = (__m256i*) &bnProcBufRes [0];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [0];
+    p_llrProcBuf256 = (__m256i*) &llrProcBuf   [0];
+    p_llrRes        = (__m256i*) &llrRes       [0];
+            for (int i=0,j=0;i<15;i++,j+=2) {
+             p_bnProcBufRes[i] = p_llrProcBuf256[i];
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j+1]);
+           ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j+1]);
+            ymmRes1 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [16128];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16128];
+    p_llrRes        = (__m256i*) &llrRes       [16128];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [17664];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16512];
+    p_llrRes        = (__m256i*) &llrRes       [16512];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [19584];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16896];
+    p_llrRes        = (__m256i*) &llrRes       [16896];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [24192];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [17664];
+    p_llrRes        = (__m256i*) &llrRes       [17664];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [34944];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [19200];
+    p_llrRes        = (__m256i*) &llrRes       [19200];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [44160];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [20352];
+    p_llrRes        = (__m256i*) &llrRes       [20352];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [47616];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [20736];
+    p_llrRes        = (__m256i*) &llrRes       [20736];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 11 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [62976];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [22272];
+    p_llrRes        = (__m256i*) &llrRes       [22272];
+            for (int i=0,j=0;i<2;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[720 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[720 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [75648];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [23424];
+    p_llrRes        = (__m256i*) &llrRes       [23424];
+            for (int i=0,j=0;i<2;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[960 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[960 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[1056 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[1056 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [94080];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [24960];
+    p_llrRes        = (__m256i*) &llrRes       [24960];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 14 CNs 
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+// Process group with <23 CNs 
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [99072];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [25344];
+    p_llrRes        = (__m256i*) &llrRes       [25344];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [109824];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [25728];
+    p_llrRes        = (__m256i*) &llrRes       [25728];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[696 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[696 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z120_R13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z120_R13_AVX2.c
new file mode 100644
index 0000000000..673af9a9d7
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z120_R13_AVX2.c
@@ -0,0 +1,749 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProcPc_BG1_Z120_R13_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes,  int8_t* llrRes ,  int8_t* llrProcBuf ) {
+   __m256i ymm0, ymm1, ymmRes0, ymmRes1;  
+        __m128i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m128i* p_llrProcBuf;
+        __m256i* p_llrProcBuf256; 
+        __m256i* p_llrRes; 
+// Process group with 1 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [0];
+    p_bnProcBufRes  = (__m256i*) &bnProcBufRes [0];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [0];
+    p_llrProcBuf256 = (__m256i*) &llrProcBuf   [0];
+    p_llrRes        = (__m256i*) &llrRes       [0];
+            for (int i=0,j=0;i<158;i++,j+=2) {
+             p_bnProcBufRes[i] = p_llrProcBuf256[i];
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j+1]);
+           ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j+1]);
+            ymmRes1 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [16128];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16128];
+    p_llrRes        = (__m256i*) &llrRes       [16128];
+        for (int i=0,j=0;i<4;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [17664];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16512];
+    p_llrRes        = (__m256i*) &llrRes       [16512];
+        for (int i=0,j=0;i<4;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [19584];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16896];
+    p_llrRes        = (__m256i*) &llrRes       [16896];
+        for (int i=0,j=0;i<8;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [24192];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [17664];
+    p_llrRes        = (__m256i*) &llrRes       [17664];
+        for (int i=0,j=0;i<15;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [34944];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [19200];
+    p_llrRes        = (__m256i*) &llrRes       [19200];
+        for (int i=0,j=0;i<12;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [44160];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [20352];
+    p_llrRes        = (__m256i*) &llrRes       [20352];
+        for (int i=0,j=0;i<4;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [47616];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [20736];
+    p_llrRes        = (__m256i*) &llrRes       [20736];
+        for (int i=0,j=0;i<15;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 11 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [62976];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [22272];
+    p_llrRes        = (__m256i*) &llrRes       [22272];
+            for (int i=0,j=0;i<12;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[720 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[720 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [75648];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [23424];
+    p_llrRes        = (__m256i*) &llrRes       [23424];
+            for (int i=0,j=0;i<15;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[960 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[960 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[1056 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[1056 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [94080];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [24960];
+    p_llrRes        = (__m256i*) &llrRes       [24960];
+        for (int i=0,j=0;i<4;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 14 CNs 
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+// Process group with <23 CNs 
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [99072];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [25344];
+    p_llrRes        = (__m256i*) &llrRes       [25344];
+        for (int i=0,j=0;i<4;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [109824];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [25728];
+    p_llrRes        = (__m256i*) &llrRes       [25728];
+        for (int i=0,j=0;i<4;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[696 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[696 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z128_R13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z128_R13_AVX2.c
new file mode 100644
index 0000000000..9029ec4945
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z128_R13_AVX2.c
@@ -0,0 +1,749 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProcPc_BG1_Z128_R13_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes,  int8_t* llrRes ,  int8_t* llrProcBuf ) {
+   __m256i ymm0, ymm1, ymmRes0, ymmRes1;  
+        __m128i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m128i* p_llrProcBuf;
+        __m256i* p_llrProcBuf256; 
+        __m256i* p_llrRes; 
+// Process group with 1 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [0];
+    p_bnProcBufRes  = (__m256i*) &bnProcBufRes [0];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [0];
+    p_llrProcBuf256 = (__m256i*) &llrProcBuf   [0];
+    p_llrRes        = (__m256i*) &llrRes       [0];
+            for (int i=0,j=0;i<168;i++,j+=2) {
+             p_bnProcBufRes[i] = p_llrProcBuf256[i];
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j+1]);
+           ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j+1]);
+            ymmRes1 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [16128];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16128];
+    p_llrRes        = (__m256i*) &llrRes       [16128];
+        for (int i=0,j=0;i<4;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [17664];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16512];
+    p_llrRes        = (__m256i*) &llrRes       [16512];
+        for (int i=0,j=0;i<4;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [19584];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16896];
+    p_llrRes        = (__m256i*) &llrRes       [16896];
+        for (int i=0,j=0;i<8;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [24192];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [17664];
+    p_llrRes        = (__m256i*) &llrRes       [17664];
+        for (int i=0,j=0;i<16;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [34944];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [19200];
+    p_llrRes        = (__m256i*) &llrRes       [19200];
+        for (int i=0,j=0;i<12;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [44160];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [20352];
+    p_llrRes        = (__m256i*) &llrRes       [20352];
+        for (int i=0,j=0;i<4;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [47616];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [20736];
+    p_llrRes        = (__m256i*) &llrRes       [20736];
+        for (int i=0,j=0;i<16;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 11 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [62976];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [22272];
+    p_llrRes        = (__m256i*) &llrRes       [22272];
+            for (int i=0,j=0;i<12;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[720 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[720 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [75648];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [23424];
+    p_llrRes        = (__m256i*) &llrRes       [23424];
+            for (int i=0,j=0;i<16;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[960 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[960 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[1056 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[1056 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [94080];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [24960];
+    p_llrRes        = (__m256i*) &llrRes       [24960];
+        for (int i=0,j=0;i<4;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 14 CNs 
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+// Process group with <23 CNs 
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [99072];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [25344];
+    p_llrRes        = (__m256i*) &llrRes       [25344];
+        for (int i=0,j=0;i<4;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [109824];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [25728];
+    p_llrRes        = (__m256i*) &llrRes       [25728];
+        for (int i=0,j=0;i<4;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[696 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[696 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z12_R13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z12_R13_AVX2.c
new file mode 100644
index 0000000000..eb63f40810
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z12_R13_AVX2.c
@@ -0,0 +1,749 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProcPc_BG1_Z12_R13_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes,  int8_t* llrRes ,  int8_t* llrProcBuf ) {
+   __m256i ymm0, ymm1, ymmRes0, ymmRes1;  
+        __m128i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m128i* p_llrProcBuf;
+        __m256i* p_llrProcBuf256; 
+        __m256i* p_llrRes; 
+// Process group with 1 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [0];
+    p_bnProcBufRes  = (__m256i*) &bnProcBufRes [0];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [0];
+    p_llrProcBuf256 = (__m256i*) &llrProcBuf   [0];
+    p_llrRes        = (__m256i*) &llrRes       [0];
+            for (int i=0,j=0;i<16;i++,j+=2) {
+             p_bnProcBufRes[i] = p_llrProcBuf256[i];
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j+1]);
+           ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j+1]);
+            ymmRes1 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [16128];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16128];
+    p_llrRes        = (__m256i*) &llrRes       [16128];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [17664];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16512];
+    p_llrRes        = (__m256i*) &llrRes       [16512];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [19584];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16896];
+    p_llrRes        = (__m256i*) &llrRes       [16896];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [24192];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [17664];
+    p_llrRes        = (__m256i*) &llrRes       [17664];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [34944];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [19200];
+    p_llrRes        = (__m256i*) &llrRes       [19200];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [44160];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [20352];
+    p_llrRes        = (__m256i*) &llrRes       [20352];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [47616];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [20736];
+    p_llrRes        = (__m256i*) &llrRes       [20736];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 11 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [62976];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [22272];
+    p_llrRes        = (__m256i*) &llrRes       [22272];
+            for (int i=0,j=0;i<2;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[720 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[720 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [75648];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [23424];
+    p_llrRes        = (__m256i*) &llrRes       [23424];
+            for (int i=0,j=0;i<2;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[960 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[960 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[1056 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[1056 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [94080];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [24960];
+    p_llrRes        = (__m256i*) &llrRes       [24960];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 14 CNs 
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+// Process group with <23 CNs 
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [99072];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [25344];
+    p_llrRes        = (__m256i*) &llrRes       [25344];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [109824];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [25728];
+    p_llrRes        = (__m256i*) &llrRes       [25728];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[696 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[696 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z13_R13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z13_R13_AVX2.c
new file mode 100644
index 0000000000..03b80c28e3
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z13_R13_AVX2.c
@@ -0,0 +1,749 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProcPc_BG1_Z13_R13_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes,  int8_t* llrRes ,  int8_t* llrProcBuf ) {
+   __m256i ymm0, ymm1, ymmRes0, ymmRes1;  
+        __m128i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m128i* p_llrProcBuf;
+        __m256i* p_llrProcBuf256; 
+        __m256i* p_llrRes; 
+// Process group with 1 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [0];
+    p_bnProcBufRes  = (__m256i*) &bnProcBufRes [0];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [0];
+    p_llrProcBuf256 = (__m256i*) &llrProcBuf   [0];
+    p_llrRes        = (__m256i*) &llrRes       [0];
+            for (int i=0,j=0;i<18;i++,j+=2) {
+             p_bnProcBufRes[i] = p_llrProcBuf256[i];
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j+1]);
+           ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j+1]);
+            ymmRes1 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [16128];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16128];
+    p_llrRes        = (__m256i*) &llrRes       [16128];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [17664];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16512];
+    p_llrRes        = (__m256i*) &llrRes       [16512];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [19584];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16896];
+    p_llrRes        = (__m256i*) &llrRes       [16896];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [24192];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [17664];
+    p_llrRes        = (__m256i*) &llrRes       [17664];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [34944];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [19200];
+    p_llrRes        = (__m256i*) &llrRes       [19200];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [44160];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [20352];
+    p_llrRes        = (__m256i*) &llrRes       [20352];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [47616];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [20736];
+    p_llrRes        = (__m256i*) &llrRes       [20736];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 11 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [62976];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [22272];
+    p_llrRes        = (__m256i*) &llrRes       [22272];
+            for (int i=0,j=0;i<2;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[720 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[720 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [75648];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [23424];
+    p_llrRes        = (__m256i*) &llrRes       [23424];
+            for (int i=0,j=0;i<2;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[960 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[960 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[1056 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[1056 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [94080];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [24960];
+    p_llrRes        = (__m256i*) &llrRes       [24960];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 14 CNs 
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+// Process group with <23 CNs 
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [99072];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [25344];
+    p_llrRes        = (__m256i*) &llrRes       [25344];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [109824];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [25728];
+    p_llrRes        = (__m256i*) &llrRes       [25728];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[696 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[696 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z144_R13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z144_R13_AVX2.c
new file mode 100644
index 0000000000..1e0e1bb9b4
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z144_R13_AVX2.c
@@ -0,0 +1,749 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProcPc_BG1_Z144_R13_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes,  int8_t* llrRes ,  int8_t* llrProcBuf ) {
+   __m256i ymm0, ymm1, ymmRes0, ymmRes1;  
+        __m128i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m128i* p_llrProcBuf;
+        __m256i* p_llrProcBuf256; 
+        __m256i* p_llrRes; 
+// Process group with 1 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [0];
+    p_bnProcBufRes  = (__m256i*) &bnProcBufRes [0];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [0];
+    p_llrProcBuf256 = (__m256i*) &llrProcBuf   [0];
+    p_llrRes        = (__m256i*) &llrRes       [0];
+            for (int i=0,j=0;i<189;i++,j+=2) {
+             p_bnProcBufRes[i] = p_llrProcBuf256[i];
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j+1]);
+           ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j+1]);
+            ymmRes1 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [16128];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16128];
+    p_llrRes        = (__m256i*) &llrRes       [16128];
+        for (int i=0,j=0;i<5;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [17664];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16512];
+    p_llrRes        = (__m256i*) &llrRes       [16512];
+        for (int i=0,j=0;i<5;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [19584];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16896];
+    p_llrRes        = (__m256i*) &llrRes       [16896];
+        for (int i=0,j=0;i<9;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [24192];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [17664];
+    p_llrRes        = (__m256i*) &llrRes       [17664];
+        for (int i=0,j=0;i<18;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [34944];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [19200];
+    p_llrRes        = (__m256i*) &llrRes       [19200];
+        for (int i=0,j=0;i<14;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [44160];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [20352];
+    p_llrRes        = (__m256i*) &llrRes       [20352];
+        for (int i=0,j=0;i<5;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [47616];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [20736];
+    p_llrRes        = (__m256i*) &llrRes       [20736];
+        for (int i=0,j=0;i<18;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 11 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [62976];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [22272];
+    p_llrRes        = (__m256i*) &llrRes       [22272];
+            for (int i=0,j=0;i<14;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[720 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[720 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [75648];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [23424];
+    p_llrRes        = (__m256i*) &llrRes       [23424];
+            for (int i=0,j=0;i<18;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[960 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[960 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[1056 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[1056 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [94080];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [24960];
+    p_llrRes        = (__m256i*) &llrRes       [24960];
+        for (int i=0,j=0;i<5;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 14 CNs 
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+// Process group with <23 CNs 
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [99072];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [25344];
+    p_llrRes        = (__m256i*) &llrRes       [25344];
+        for (int i=0,j=0;i<5;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [109824];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [25728];
+    p_llrRes        = (__m256i*) &llrRes       [25728];
+        for (int i=0,j=0;i<5;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[696 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[696 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z14_R13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z14_R13_AVX2.c
new file mode 100644
index 0000000000..f8d5ba2422
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z14_R13_AVX2.c
@@ -0,0 +1,749 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProcPc_BG1_Z14_R13_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes,  int8_t* llrRes ,  int8_t* llrProcBuf ) {
+   __m256i ymm0, ymm1, ymmRes0, ymmRes1;  
+        __m128i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m128i* p_llrProcBuf;
+        __m256i* p_llrProcBuf256; 
+        __m256i* p_llrRes; 
+// Process group with 1 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [0];
+    p_bnProcBufRes  = (__m256i*) &bnProcBufRes [0];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [0];
+    p_llrProcBuf256 = (__m256i*) &llrProcBuf   [0];
+    p_llrRes        = (__m256i*) &llrRes       [0];
+            for (int i=0,j=0;i<19;i++,j+=2) {
+             p_bnProcBufRes[i] = p_llrProcBuf256[i];
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j+1]);
+           ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j+1]);
+            ymmRes1 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [16128];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16128];
+    p_llrRes        = (__m256i*) &llrRes       [16128];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [17664];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16512];
+    p_llrRes        = (__m256i*) &llrRes       [16512];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [19584];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16896];
+    p_llrRes        = (__m256i*) &llrRes       [16896];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [24192];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [17664];
+    p_llrRes        = (__m256i*) &llrRes       [17664];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [34944];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [19200];
+    p_llrRes        = (__m256i*) &llrRes       [19200];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [44160];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [20352];
+    p_llrRes        = (__m256i*) &llrRes       [20352];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [47616];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [20736];
+    p_llrRes        = (__m256i*) &llrRes       [20736];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 11 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [62976];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [22272];
+    p_llrRes        = (__m256i*) &llrRes       [22272];
+            for (int i=0,j=0;i<2;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[720 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[720 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [75648];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [23424];
+    p_llrRes        = (__m256i*) &llrRes       [23424];
+            for (int i=0,j=0;i<2;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[960 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[960 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[1056 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[1056 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [94080];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [24960];
+    p_llrRes        = (__m256i*) &llrRes       [24960];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 14 CNs 
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+// Process group with <23 CNs 
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [99072];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [25344];
+    p_llrRes        = (__m256i*) &llrRes       [25344];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [109824];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [25728];
+    p_llrRes        = (__m256i*) &llrRes       [25728];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[696 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[696 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z15_R13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z15_R13_AVX2.c
new file mode 100644
index 0000000000..c3bf9cd8c4
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z15_R13_AVX2.c
@@ -0,0 +1,749 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProcPc_BG1_Z15_R13_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes,  int8_t* llrRes ,  int8_t* llrProcBuf ) {
+   __m256i ymm0, ymm1, ymmRes0, ymmRes1;  
+        __m128i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m128i* p_llrProcBuf;
+        __m256i* p_llrProcBuf256; 
+        __m256i* p_llrRes; 
+// Process group with 1 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [0];
+    p_bnProcBufRes  = (__m256i*) &bnProcBufRes [0];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [0];
+    p_llrProcBuf256 = (__m256i*) &llrProcBuf   [0];
+    p_llrRes        = (__m256i*) &llrRes       [0];
+            for (int i=0,j=0;i<20;i++,j+=2) {
+             p_bnProcBufRes[i] = p_llrProcBuf256[i];
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j+1]);
+           ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j+1]);
+            ymmRes1 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [16128];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16128];
+    p_llrRes        = (__m256i*) &llrRes       [16128];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [17664];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16512];
+    p_llrRes        = (__m256i*) &llrRes       [16512];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [19584];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16896];
+    p_llrRes        = (__m256i*) &llrRes       [16896];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [24192];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [17664];
+    p_llrRes        = (__m256i*) &llrRes       [17664];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [34944];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [19200];
+    p_llrRes        = (__m256i*) &llrRes       [19200];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [44160];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [20352];
+    p_llrRes        = (__m256i*) &llrRes       [20352];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [47616];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [20736];
+    p_llrRes        = (__m256i*) &llrRes       [20736];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 11 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [62976];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [22272];
+    p_llrRes        = (__m256i*) &llrRes       [22272];
+            for (int i=0,j=0;i<2;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[720 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[720 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [75648];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [23424];
+    p_llrRes        = (__m256i*) &llrRes       [23424];
+            for (int i=0,j=0;i<2;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[960 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[960 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[1056 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[1056 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [94080];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [24960];
+    p_llrRes        = (__m256i*) &llrRes       [24960];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 14 CNs 
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+// Process group with <23 CNs 
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [99072];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [25344];
+    p_llrRes        = (__m256i*) &llrRes       [25344];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [109824];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [25728];
+    p_llrRes        = (__m256i*) &llrRes       [25728];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[696 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[696 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z160_R13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z160_R13_AVX2.c
new file mode 100644
index 0000000000..54aa60410d
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z160_R13_AVX2.c
@@ -0,0 +1,749 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProcPc_BG1_Z160_R13_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes,  int8_t* llrRes ,  int8_t* llrProcBuf ) {
+   __m256i ymm0, ymm1, ymmRes0, ymmRes1;  
+        __m128i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m128i* p_llrProcBuf;
+        __m256i* p_llrProcBuf256; 
+        __m256i* p_llrRes; 
+// Process group with 1 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [0];
+    p_bnProcBufRes  = (__m256i*) &bnProcBufRes [0];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [0];
+    p_llrProcBuf256 = (__m256i*) &llrProcBuf   [0];
+    p_llrRes        = (__m256i*) &llrRes       [0];
+            for (int i=0,j=0;i<210;i++,j+=2) {
+             p_bnProcBufRes[i] = p_llrProcBuf256[i];
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j+1]);
+           ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j+1]);
+            ymmRes1 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [16128];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16128];
+    p_llrRes        = (__m256i*) &llrRes       [16128];
+        for (int i=0,j=0;i<5;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [17664];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16512];
+    p_llrRes        = (__m256i*) &llrRes       [16512];
+        for (int i=0,j=0;i<5;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [19584];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16896];
+    p_llrRes        = (__m256i*) &llrRes       [16896];
+        for (int i=0,j=0;i<10;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [24192];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [17664];
+    p_llrRes        = (__m256i*) &llrRes       [17664];
+        for (int i=0,j=0;i<20;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [34944];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [19200];
+    p_llrRes        = (__m256i*) &llrRes       [19200];
+        for (int i=0,j=0;i<15;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [44160];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [20352];
+    p_llrRes        = (__m256i*) &llrRes       [20352];
+        for (int i=0,j=0;i<5;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [47616];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [20736];
+    p_llrRes        = (__m256i*) &llrRes       [20736];
+        for (int i=0,j=0;i<20;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 11 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [62976];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [22272];
+    p_llrRes        = (__m256i*) &llrRes       [22272];
+            for (int i=0,j=0;i<15;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[720 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[720 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [75648];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [23424];
+    p_llrRes        = (__m256i*) &llrRes       [23424];
+            for (int i=0,j=0;i<20;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[960 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[960 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[1056 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[1056 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [94080];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [24960];
+    p_llrRes        = (__m256i*) &llrRes       [24960];
+        for (int i=0,j=0;i<5;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 14 CNs 
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+// Process group with <23 CNs 
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [99072];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [25344];
+    p_llrRes        = (__m256i*) &llrRes       [25344];
+        for (int i=0,j=0;i<5;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [109824];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [25728];
+    p_llrRes        = (__m256i*) &llrRes       [25728];
+        for (int i=0,j=0;i<5;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[696 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[696 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z16_R13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z16_R13_AVX2.c
new file mode 100644
index 0000000000..dbd57a29a2
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z16_R13_AVX2.c
@@ -0,0 +1,749 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProcPc_BG1_Z16_R13_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes,  int8_t* llrRes ,  int8_t* llrProcBuf ) {
+   __m256i ymm0, ymm1, ymmRes0, ymmRes1;  
+        __m128i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m128i* p_llrProcBuf;
+        __m256i* p_llrProcBuf256; 
+        __m256i* p_llrRes; 
+// Process group with 1 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [0];
+    p_bnProcBufRes  = (__m256i*) &bnProcBufRes [0];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [0];
+    p_llrProcBuf256 = (__m256i*) &llrProcBuf   [0];
+    p_llrRes        = (__m256i*) &llrRes       [0];
+            for (int i=0,j=0;i<21;i++,j+=2) {
+             p_bnProcBufRes[i] = p_llrProcBuf256[i];
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j+1]);
+           ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j+1]);
+            ymmRes1 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [16128];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16128];
+    p_llrRes        = (__m256i*) &llrRes       [16128];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [17664];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16512];
+    p_llrRes        = (__m256i*) &llrRes       [16512];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [19584];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16896];
+    p_llrRes        = (__m256i*) &llrRes       [16896];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [24192];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [17664];
+    p_llrRes        = (__m256i*) &llrRes       [17664];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [34944];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [19200];
+    p_llrRes        = (__m256i*) &llrRes       [19200];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [44160];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [20352];
+    p_llrRes        = (__m256i*) &llrRes       [20352];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [47616];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [20736];
+    p_llrRes        = (__m256i*) &llrRes       [20736];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 11 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [62976];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [22272];
+    p_llrRes        = (__m256i*) &llrRes       [22272];
+            for (int i=0,j=0;i<2;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[720 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[720 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [75648];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [23424];
+    p_llrRes        = (__m256i*) &llrRes       [23424];
+            for (int i=0,j=0;i<2;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[960 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[960 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[1056 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[1056 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [94080];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [24960];
+    p_llrRes        = (__m256i*) &llrRes       [24960];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 14 CNs 
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+// Process group with <23 CNs 
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [99072];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [25344];
+    p_llrRes        = (__m256i*) &llrRes       [25344];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [109824];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [25728];
+    p_llrRes        = (__m256i*) &llrRes       [25728];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[696 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[696 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z176_R13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z176_R13_AVX2.c
new file mode 100644
index 0000000000..b33f7eff95
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z176_R13_AVX2.c
@@ -0,0 +1,749 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProcPc_BG1_Z176_R13_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes,  int8_t* llrRes ,  int8_t* llrProcBuf ) {
+   __m256i ymm0, ymm1, ymmRes0, ymmRes1;  
+        __m128i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m128i* p_llrProcBuf;
+        __m256i* p_llrProcBuf256; 
+        __m256i* p_llrRes; 
+// Process group with 1 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [0];
+    p_bnProcBufRes  = (__m256i*) &bnProcBufRes [0];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [0];
+    p_llrProcBuf256 = (__m256i*) &llrProcBuf   [0];
+    p_llrRes        = (__m256i*) &llrRes       [0];
+            for (int i=0,j=0;i<231;i++,j+=2) {
+             p_bnProcBufRes[i] = p_llrProcBuf256[i];
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j+1]);
+           ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j+1]);
+            ymmRes1 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [16128];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16128];
+    p_llrRes        = (__m256i*) &llrRes       [16128];
+        for (int i=0,j=0;i<6;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [17664];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16512];
+    p_llrRes        = (__m256i*) &llrRes       [16512];
+        for (int i=0,j=0;i<6;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [19584];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16896];
+    p_llrRes        = (__m256i*) &llrRes       [16896];
+        for (int i=0,j=0;i<11;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [24192];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [17664];
+    p_llrRes        = (__m256i*) &llrRes       [17664];
+        for (int i=0,j=0;i<22;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [34944];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [19200];
+    p_llrRes        = (__m256i*) &llrRes       [19200];
+        for (int i=0,j=0;i<17;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [44160];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [20352];
+    p_llrRes        = (__m256i*) &llrRes       [20352];
+        for (int i=0,j=0;i<6;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [47616];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [20736];
+    p_llrRes        = (__m256i*) &llrRes       [20736];
+        for (int i=0,j=0;i<22;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 11 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [62976];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [22272];
+    p_llrRes        = (__m256i*) &llrRes       [22272];
+            for (int i=0,j=0;i<17;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[720 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[720 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [75648];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [23424];
+    p_llrRes        = (__m256i*) &llrRes       [23424];
+            for (int i=0,j=0;i<22;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[960 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[960 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[1056 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[1056 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [94080];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [24960];
+    p_llrRes        = (__m256i*) &llrRes       [24960];
+        for (int i=0,j=0;i<6;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 14 CNs 
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+// Process group with <23 CNs 
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [99072];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [25344];
+    p_llrRes        = (__m256i*) &llrRes       [25344];
+        for (int i=0,j=0;i<6;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [109824];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [25728];
+    p_llrRes        = (__m256i*) &llrRes       [25728];
+        for (int i=0,j=0;i<6;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[696 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[696 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z18_R13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z18_R13_AVX2.c
new file mode 100644
index 0000000000..bfacf24f9e
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z18_R13_AVX2.c
@@ -0,0 +1,749 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProcPc_BG1_Z18_R13_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes,  int8_t* llrRes ,  int8_t* llrProcBuf ) {
+   __m256i ymm0, ymm1, ymmRes0, ymmRes1;  
+        __m128i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m128i* p_llrProcBuf;
+        __m256i* p_llrProcBuf256; 
+        __m256i* p_llrRes; 
+// Process group with 1 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [0];
+    p_bnProcBufRes  = (__m256i*) &bnProcBufRes [0];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [0];
+    p_llrProcBuf256 = (__m256i*) &llrProcBuf   [0];
+    p_llrRes        = (__m256i*) &llrRes       [0];
+            for (int i=0,j=0;i<24;i++,j+=2) {
+             p_bnProcBufRes[i] = p_llrProcBuf256[i];
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j+1]);
+           ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j+1]);
+            ymmRes1 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [16128];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16128];
+    p_llrRes        = (__m256i*) &llrRes       [16128];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [17664];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16512];
+    p_llrRes        = (__m256i*) &llrRes       [16512];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [19584];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16896];
+    p_llrRes        = (__m256i*) &llrRes       [16896];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [24192];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [17664];
+    p_llrRes        = (__m256i*) &llrRes       [17664];
+        for (int i=0,j=0;i<3;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [34944];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [19200];
+    p_llrRes        = (__m256i*) &llrRes       [19200];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [44160];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [20352];
+    p_llrRes        = (__m256i*) &llrRes       [20352];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [47616];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [20736];
+    p_llrRes        = (__m256i*) &llrRes       [20736];
+        for (int i=0,j=0;i<3;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 11 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [62976];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [22272];
+    p_llrRes        = (__m256i*) &llrRes       [22272];
+            for (int i=0,j=0;i<2;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[720 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[720 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [75648];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [23424];
+    p_llrRes        = (__m256i*) &llrRes       [23424];
+            for (int i=0,j=0;i<3;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[960 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[960 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[1056 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[1056 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [94080];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [24960];
+    p_llrRes        = (__m256i*) &llrRes       [24960];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 14 CNs 
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+// Process group with <23 CNs 
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [99072];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [25344];
+    p_llrRes        = (__m256i*) &llrRes       [25344];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [109824];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [25728];
+    p_llrRes        = (__m256i*) &llrRes       [25728];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[696 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[696 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z192_R13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z192_R13_AVX2.c
new file mode 100644
index 0000000000..cb5e28d03b
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z192_R13_AVX2.c
@@ -0,0 +1,749 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProcPc_BG1_Z192_R13_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes,  int8_t* llrRes ,  int8_t* llrProcBuf ) {
+   __m256i ymm0, ymm1, ymmRes0, ymmRes1;  
+        __m128i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m128i* p_llrProcBuf;
+        __m256i* p_llrProcBuf256; 
+        __m256i* p_llrRes; 
+// Process group with 1 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [0];
+    p_bnProcBufRes  = (__m256i*) &bnProcBufRes [0];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [0];
+    p_llrProcBuf256 = (__m256i*) &llrProcBuf   [0];
+    p_llrRes        = (__m256i*) &llrRes       [0];
+            for (int i=0,j=0;i<252;i++,j+=2) {
+             p_bnProcBufRes[i] = p_llrProcBuf256[i];
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j+1]);
+           ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j+1]);
+            ymmRes1 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [16128];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16128];
+    p_llrRes        = (__m256i*) &llrRes       [16128];
+        for (int i=0,j=0;i<6;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [17664];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16512];
+    p_llrRes        = (__m256i*) &llrRes       [16512];
+        for (int i=0,j=0;i<6;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [19584];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16896];
+    p_llrRes        = (__m256i*) &llrRes       [16896];
+        for (int i=0,j=0;i<12;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [24192];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [17664];
+    p_llrRes        = (__m256i*) &llrRes       [17664];
+        for (int i=0,j=0;i<24;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [34944];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [19200];
+    p_llrRes        = (__m256i*) &llrRes       [19200];
+        for (int i=0,j=0;i<18;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [44160];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [20352];
+    p_llrRes        = (__m256i*) &llrRes       [20352];
+        for (int i=0,j=0;i<6;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [47616];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [20736];
+    p_llrRes        = (__m256i*) &llrRes       [20736];
+        for (int i=0,j=0;i<24;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 11 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [62976];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [22272];
+    p_llrRes        = (__m256i*) &llrRes       [22272];
+            for (int i=0,j=0;i<18;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[720 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[720 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [75648];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [23424];
+    p_llrRes        = (__m256i*) &llrRes       [23424];
+            for (int i=0,j=0;i<24;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[960 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[960 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[1056 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[1056 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [94080];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [24960];
+    p_llrRes        = (__m256i*) &llrRes       [24960];
+        for (int i=0,j=0;i<6;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 14 CNs 
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+// Process group with <23 CNs 
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [99072];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [25344];
+    p_llrRes        = (__m256i*) &llrRes       [25344];
+        for (int i=0,j=0;i<6;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [109824];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [25728];
+    p_llrRes        = (__m256i*) &llrRes       [25728];
+        for (int i=0,j=0;i<6;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[696 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[696 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z208_R13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z208_R13_AVX2.c
new file mode 100644
index 0000000000..26206a90ef
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z208_R13_AVX2.c
@@ -0,0 +1,749 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProcPc_BG1_Z208_R13_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes,  int8_t* llrRes ,  int8_t* llrProcBuf ) {
+   __m256i ymm0, ymm1, ymmRes0, ymmRes1;  
+        __m128i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m128i* p_llrProcBuf;
+        __m256i* p_llrProcBuf256; 
+        __m256i* p_llrRes; 
+// Process group with 1 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [0];
+    p_bnProcBufRes  = (__m256i*) &bnProcBufRes [0];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [0];
+    p_llrProcBuf256 = (__m256i*) &llrProcBuf   [0];
+    p_llrRes        = (__m256i*) &llrRes       [0];
+            for (int i=0,j=0;i<273;i++,j+=2) {
+             p_bnProcBufRes[i] = p_llrProcBuf256[i];
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j+1]);
+           ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j+1]);
+            ymmRes1 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [16128];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16128];
+    p_llrRes        = (__m256i*) &llrRes       [16128];
+        for (int i=0,j=0;i<7;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [17664];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16512];
+    p_llrRes        = (__m256i*) &llrRes       [16512];
+        for (int i=0,j=0;i<7;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [19584];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16896];
+    p_llrRes        = (__m256i*) &llrRes       [16896];
+        for (int i=0,j=0;i<13;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [24192];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [17664];
+    p_llrRes        = (__m256i*) &llrRes       [17664];
+        for (int i=0,j=0;i<26;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [34944];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [19200];
+    p_llrRes        = (__m256i*) &llrRes       [19200];
+        for (int i=0,j=0;i<20;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [44160];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [20352];
+    p_llrRes        = (__m256i*) &llrRes       [20352];
+        for (int i=0,j=0;i<7;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [47616];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [20736];
+    p_llrRes        = (__m256i*) &llrRes       [20736];
+        for (int i=0,j=0;i<26;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 11 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [62976];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [22272];
+    p_llrRes        = (__m256i*) &llrRes       [22272];
+            for (int i=0,j=0;i<20;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[720 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[720 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [75648];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [23424];
+    p_llrRes        = (__m256i*) &llrRes       [23424];
+            for (int i=0,j=0;i<26;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[960 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[960 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[1056 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[1056 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [94080];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [24960];
+    p_llrRes        = (__m256i*) &llrRes       [24960];
+        for (int i=0,j=0;i<7;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 14 CNs 
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+// Process group with <23 CNs 
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [99072];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [25344];
+    p_llrRes        = (__m256i*) &llrRes       [25344];
+        for (int i=0,j=0;i<7;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [109824];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [25728];
+    p_llrRes        = (__m256i*) &llrRes       [25728];
+        for (int i=0,j=0;i<7;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[696 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[696 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z20_R13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z20_R13_AVX2.c
new file mode 100644
index 0000000000..47a80af761
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z20_R13_AVX2.c
@@ -0,0 +1,749 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProcPc_BG1_Z20_R13_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes,  int8_t* llrRes ,  int8_t* llrProcBuf ) {
+   __m256i ymm0, ymm1, ymmRes0, ymmRes1;  
+        __m128i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m128i* p_llrProcBuf;
+        __m256i* p_llrProcBuf256; 
+        __m256i* p_llrRes; 
+// Process group with 1 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [0];
+    p_bnProcBufRes  = (__m256i*) &bnProcBufRes [0];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [0];
+    p_llrProcBuf256 = (__m256i*) &llrProcBuf   [0];
+    p_llrRes        = (__m256i*) &llrRes       [0];
+            for (int i=0,j=0;i<27;i++,j+=2) {
+             p_bnProcBufRes[i] = p_llrProcBuf256[i];
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j+1]);
+           ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j+1]);
+            ymmRes1 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [16128];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16128];
+    p_llrRes        = (__m256i*) &llrRes       [16128];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [17664];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16512];
+    p_llrRes        = (__m256i*) &llrRes       [16512];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [19584];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16896];
+    p_llrRes        = (__m256i*) &llrRes       [16896];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [24192];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [17664];
+    p_llrRes        = (__m256i*) &llrRes       [17664];
+        for (int i=0,j=0;i<3;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [34944];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [19200];
+    p_llrRes        = (__m256i*) &llrRes       [19200];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [44160];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [20352];
+    p_llrRes        = (__m256i*) &llrRes       [20352];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [47616];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [20736];
+    p_llrRes        = (__m256i*) &llrRes       [20736];
+        for (int i=0,j=0;i<3;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 11 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [62976];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [22272];
+    p_llrRes        = (__m256i*) &llrRes       [22272];
+            for (int i=0,j=0;i<2;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[720 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[720 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [75648];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [23424];
+    p_llrRes        = (__m256i*) &llrRes       [23424];
+            for (int i=0,j=0;i<3;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[960 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[960 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[1056 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[1056 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [94080];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [24960];
+    p_llrRes        = (__m256i*) &llrRes       [24960];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 14 CNs 
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+// Process group with <23 CNs 
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [99072];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [25344];
+    p_llrRes        = (__m256i*) &llrRes       [25344];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [109824];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [25728];
+    p_llrRes        = (__m256i*) &llrRes       [25728];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[696 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[696 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z224_R13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z224_R13_AVX2.c
new file mode 100644
index 0000000000..429e77bb46
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z224_R13_AVX2.c
@@ -0,0 +1,749 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProcPc_BG1_Z224_R13_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes,  int8_t* llrRes ,  int8_t* llrProcBuf ) {
+   __m256i ymm0, ymm1, ymmRes0, ymmRes1;  
+        __m128i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m128i* p_llrProcBuf;
+        __m256i* p_llrProcBuf256; 
+        __m256i* p_llrRes; 
+// Process group with 1 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [0];
+    p_bnProcBufRes  = (__m256i*) &bnProcBufRes [0];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [0];
+    p_llrProcBuf256 = (__m256i*) &llrProcBuf   [0];
+    p_llrRes        = (__m256i*) &llrRes       [0];
+            for (int i=0,j=0;i<294;i++,j+=2) {
+             p_bnProcBufRes[i] = p_llrProcBuf256[i];
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j+1]);
+           ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j+1]);
+            ymmRes1 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [16128];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16128];
+    p_llrRes        = (__m256i*) &llrRes       [16128];
+        for (int i=0,j=0;i<7;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [17664];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16512];
+    p_llrRes        = (__m256i*) &llrRes       [16512];
+        for (int i=0,j=0;i<7;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [19584];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16896];
+    p_llrRes        = (__m256i*) &llrRes       [16896];
+        for (int i=0,j=0;i<14;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [24192];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [17664];
+    p_llrRes        = (__m256i*) &llrRes       [17664];
+        for (int i=0,j=0;i<28;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [34944];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [19200];
+    p_llrRes        = (__m256i*) &llrRes       [19200];
+        for (int i=0,j=0;i<21;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [44160];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [20352];
+    p_llrRes        = (__m256i*) &llrRes       [20352];
+        for (int i=0,j=0;i<7;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [47616];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [20736];
+    p_llrRes        = (__m256i*) &llrRes       [20736];
+        for (int i=0,j=0;i<28;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 11 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [62976];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [22272];
+    p_llrRes        = (__m256i*) &llrRes       [22272];
+            for (int i=0,j=0;i<21;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[720 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[720 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [75648];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [23424];
+    p_llrRes        = (__m256i*) &llrRes       [23424];
+            for (int i=0,j=0;i<28;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[960 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[960 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[1056 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[1056 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [94080];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [24960];
+    p_llrRes        = (__m256i*) &llrRes       [24960];
+        for (int i=0,j=0;i<7;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 14 CNs 
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+// Process group with <23 CNs 
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [99072];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [25344];
+    p_llrRes        = (__m256i*) &llrRes       [25344];
+        for (int i=0,j=0;i<7;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [109824];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [25728];
+    p_llrRes        = (__m256i*) &llrRes       [25728];
+        for (int i=0,j=0;i<7;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[696 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[696 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z22_R13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z22_R13_AVX2.c
new file mode 100644
index 0000000000..5114d701ea
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z22_R13_AVX2.c
@@ -0,0 +1,749 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProcPc_BG1_Z22_R13_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes,  int8_t* llrRes ,  int8_t* llrProcBuf ) {
+   __m256i ymm0, ymm1, ymmRes0, ymmRes1;  
+        __m128i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m128i* p_llrProcBuf;
+        __m256i* p_llrProcBuf256; 
+        __m256i* p_llrRes; 
+// Process group with 1 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [0];
+    p_bnProcBufRes  = (__m256i*) &bnProcBufRes [0];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [0];
+    p_llrProcBuf256 = (__m256i*) &llrProcBuf   [0];
+    p_llrRes        = (__m256i*) &llrRes       [0];
+            for (int i=0,j=0;i<29;i++,j+=2) {
+             p_bnProcBufRes[i] = p_llrProcBuf256[i];
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j+1]);
+           ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j+1]);
+            ymmRes1 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [16128];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16128];
+    p_llrRes        = (__m256i*) &llrRes       [16128];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [17664];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16512];
+    p_llrRes        = (__m256i*) &llrRes       [16512];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [19584];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16896];
+    p_llrRes        = (__m256i*) &llrRes       [16896];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [24192];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [17664];
+    p_llrRes        = (__m256i*) &llrRes       [17664];
+        for (int i=0,j=0;i<3;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [34944];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [19200];
+    p_llrRes        = (__m256i*) &llrRes       [19200];
+        for (int i=0,j=0;i<3;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [44160];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [20352];
+    p_llrRes        = (__m256i*) &llrRes       [20352];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [47616];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [20736];
+    p_llrRes        = (__m256i*) &llrRes       [20736];
+        for (int i=0,j=0;i<3;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 11 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [62976];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [22272];
+    p_llrRes        = (__m256i*) &llrRes       [22272];
+            for (int i=0,j=0;i<3;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[720 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[720 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [75648];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [23424];
+    p_llrRes        = (__m256i*) &llrRes       [23424];
+            for (int i=0,j=0;i<3;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[960 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[960 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[1056 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[1056 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [94080];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [24960];
+    p_llrRes        = (__m256i*) &llrRes       [24960];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 14 CNs 
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+// Process group with <23 CNs 
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [99072];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [25344];
+    p_llrRes        = (__m256i*) &llrRes       [25344];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [109824];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [25728];
+    p_llrRes        = (__m256i*) &llrRes       [25728];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[696 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[696 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z240_R13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z240_R13_AVX2.c
new file mode 100644
index 0000000000..0075be8dec
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z240_R13_AVX2.c
@@ -0,0 +1,749 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProcPc_BG1_Z240_R13_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes,  int8_t* llrRes ,  int8_t* llrProcBuf ) {
+   __m256i ymm0, ymm1, ymmRes0, ymmRes1;  
+        __m128i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m128i* p_llrProcBuf;
+        __m256i* p_llrProcBuf256; 
+        __m256i* p_llrRes; 
+// Process group with 1 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [0];
+    p_bnProcBufRes  = (__m256i*) &bnProcBufRes [0];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [0];
+    p_llrProcBuf256 = (__m256i*) &llrProcBuf   [0];
+    p_llrRes        = (__m256i*) &llrRes       [0];
+            for (int i=0,j=0;i<315;i++,j+=2) {
+             p_bnProcBufRes[i] = p_llrProcBuf256[i];
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j+1]);
+           ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j+1]);
+            ymmRes1 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [16128];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16128];
+    p_llrRes        = (__m256i*) &llrRes       [16128];
+        for (int i=0,j=0;i<8;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [17664];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16512];
+    p_llrRes        = (__m256i*) &llrRes       [16512];
+        for (int i=0,j=0;i<8;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [19584];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16896];
+    p_llrRes        = (__m256i*) &llrRes       [16896];
+        for (int i=0,j=0;i<15;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [24192];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [17664];
+    p_llrRes        = (__m256i*) &llrRes       [17664];
+        for (int i=0,j=0;i<30;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [34944];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [19200];
+    p_llrRes        = (__m256i*) &llrRes       [19200];
+        for (int i=0,j=0;i<23;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [44160];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [20352];
+    p_llrRes        = (__m256i*) &llrRes       [20352];
+        for (int i=0,j=0;i<8;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [47616];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [20736];
+    p_llrRes        = (__m256i*) &llrRes       [20736];
+        for (int i=0,j=0;i<30;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 11 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [62976];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [22272];
+    p_llrRes        = (__m256i*) &llrRes       [22272];
+            for (int i=0,j=0;i<23;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[720 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[720 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [75648];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [23424];
+    p_llrRes        = (__m256i*) &llrRes       [23424];
+            for (int i=0,j=0;i<30;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[960 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[960 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[1056 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[1056 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [94080];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [24960];
+    p_llrRes        = (__m256i*) &llrRes       [24960];
+        for (int i=0,j=0;i<8;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 14 CNs 
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+// Process group with <23 CNs 
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [99072];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [25344];
+    p_llrRes        = (__m256i*) &llrRes       [25344];
+        for (int i=0,j=0;i<8;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [109824];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [25728];
+    p_llrRes        = (__m256i*) &llrRes       [25728];
+        for (int i=0,j=0;i<8;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[696 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[696 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z24_R13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z24_R13_AVX2.c
new file mode 100644
index 0000000000..2a10721f55
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z24_R13_AVX2.c
@@ -0,0 +1,749 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProcPc_BG1_Z24_R13_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes,  int8_t* llrRes ,  int8_t* llrProcBuf ) {
+   __m256i ymm0, ymm1, ymmRes0, ymmRes1;  
+        __m128i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m128i* p_llrProcBuf;
+        __m256i* p_llrProcBuf256; 
+        __m256i* p_llrRes; 
+// Process group with 1 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [0];
+    p_bnProcBufRes  = (__m256i*) &bnProcBufRes [0];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [0];
+    p_llrProcBuf256 = (__m256i*) &llrProcBuf   [0];
+    p_llrRes        = (__m256i*) &llrRes       [0];
+            for (int i=0,j=0;i<32;i++,j+=2) {
+             p_bnProcBufRes[i] = p_llrProcBuf256[i];
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j+1]);
+           ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j+1]);
+            ymmRes1 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [16128];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16128];
+    p_llrRes        = (__m256i*) &llrRes       [16128];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [17664];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16512];
+    p_llrRes        = (__m256i*) &llrRes       [16512];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [19584];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16896];
+    p_llrRes        = (__m256i*) &llrRes       [16896];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [24192];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [17664];
+    p_llrRes        = (__m256i*) &llrRes       [17664];
+        for (int i=0,j=0;i<3;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [34944];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [19200];
+    p_llrRes        = (__m256i*) &llrRes       [19200];
+        for (int i=0,j=0;i<3;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [44160];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [20352];
+    p_llrRes        = (__m256i*) &llrRes       [20352];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [47616];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [20736];
+    p_llrRes        = (__m256i*) &llrRes       [20736];
+        for (int i=0,j=0;i<3;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 11 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [62976];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [22272];
+    p_llrRes        = (__m256i*) &llrRes       [22272];
+            for (int i=0,j=0;i<3;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[720 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[720 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [75648];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [23424];
+    p_llrRes        = (__m256i*) &llrRes       [23424];
+            for (int i=0,j=0;i<3;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[960 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[960 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[1056 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[1056 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [94080];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [24960];
+    p_llrRes        = (__m256i*) &llrRes       [24960];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 14 CNs 
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+// Process group with <23 CNs 
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [99072];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [25344];
+    p_llrRes        = (__m256i*) &llrRes       [25344];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [109824];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [25728];
+    p_llrRes        = (__m256i*) &llrRes       [25728];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[696 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[696 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z256_R13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z256_R13_AVX2.c
new file mode 100644
index 0000000000..32f7cc2f18
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z256_R13_AVX2.c
@@ -0,0 +1,749 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProcPc_BG1_Z256_R13_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes,  int8_t* llrRes ,  int8_t* llrProcBuf ) {
+   __m256i ymm0, ymm1, ymmRes0, ymmRes1;  
+        __m128i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m128i* p_llrProcBuf;
+        __m256i* p_llrProcBuf256; 
+        __m256i* p_llrRes; 
+// Process group with 1 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [0];
+    p_bnProcBufRes  = (__m256i*) &bnProcBufRes [0];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [0];
+    p_llrProcBuf256 = (__m256i*) &llrProcBuf   [0];
+    p_llrRes        = (__m256i*) &llrRes       [0];
+            for (int i=0,j=0;i<336;i++,j+=2) {
+             p_bnProcBufRes[i] = p_llrProcBuf256[i];
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j+1]);
+           ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j+1]);
+            ymmRes1 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [16128];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16128];
+    p_llrRes        = (__m256i*) &llrRes       [16128];
+        for (int i=0,j=0;i<8;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [17664];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16512];
+    p_llrRes        = (__m256i*) &llrRes       [16512];
+        for (int i=0,j=0;i<8;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [19584];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16896];
+    p_llrRes        = (__m256i*) &llrRes       [16896];
+        for (int i=0,j=0;i<16;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [24192];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [17664];
+    p_llrRes        = (__m256i*) &llrRes       [17664];
+        for (int i=0,j=0;i<32;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [34944];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [19200];
+    p_llrRes        = (__m256i*) &llrRes       [19200];
+        for (int i=0,j=0;i<24;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [44160];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [20352];
+    p_llrRes        = (__m256i*) &llrRes       [20352];
+        for (int i=0,j=0;i<8;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [47616];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [20736];
+    p_llrRes        = (__m256i*) &llrRes       [20736];
+        for (int i=0,j=0;i<32;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 11 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [62976];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [22272];
+    p_llrRes        = (__m256i*) &llrRes       [22272];
+            for (int i=0,j=0;i<24;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[720 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[720 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [75648];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [23424];
+    p_llrRes        = (__m256i*) &llrRes       [23424];
+            for (int i=0,j=0;i<32;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[960 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[960 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[1056 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[1056 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [94080];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [24960];
+    p_llrRes        = (__m256i*) &llrRes       [24960];
+        for (int i=0,j=0;i<8;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 14 CNs 
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+// Process group with <23 CNs 
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [99072];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [25344];
+    p_llrRes        = (__m256i*) &llrRes       [25344];
+        for (int i=0,j=0;i<8;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [109824];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [25728];
+    p_llrRes        = (__m256i*) &llrRes       [25728];
+        for (int i=0,j=0;i<8;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[696 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[696 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z26_R13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z26_R13_AVX2.c
new file mode 100644
index 0000000000..ec50dbc7c6
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z26_R13_AVX2.c
@@ -0,0 +1,749 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProcPc_BG1_Z26_R13_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes,  int8_t* llrRes ,  int8_t* llrProcBuf ) {
+   __m256i ymm0, ymm1, ymmRes0, ymmRes1;  
+        __m128i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m128i* p_llrProcBuf;
+        __m256i* p_llrProcBuf256; 
+        __m256i* p_llrRes; 
+// Process group with 1 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [0];
+    p_bnProcBufRes  = (__m256i*) &bnProcBufRes [0];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [0];
+    p_llrProcBuf256 = (__m256i*) &llrProcBuf   [0];
+    p_llrRes        = (__m256i*) &llrRes       [0];
+            for (int i=0,j=0;i<35;i++,j+=2) {
+             p_bnProcBufRes[i] = p_llrProcBuf256[i];
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j+1]);
+           ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j+1]);
+            ymmRes1 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [16128];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16128];
+    p_llrRes        = (__m256i*) &llrRes       [16128];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [17664];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16512];
+    p_llrRes        = (__m256i*) &llrRes       [16512];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [19584];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16896];
+    p_llrRes        = (__m256i*) &llrRes       [16896];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [24192];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [17664];
+    p_llrRes        = (__m256i*) &llrRes       [17664];
+        for (int i=0,j=0;i<4;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [34944];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [19200];
+    p_llrRes        = (__m256i*) &llrRes       [19200];
+        for (int i=0,j=0;i<3;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [44160];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [20352];
+    p_llrRes        = (__m256i*) &llrRes       [20352];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [47616];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [20736];
+    p_llrRes        = (__m256i*) &llrRes       [20736];
+        for (int i=0,j=0;i<4;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 11 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [62976];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [22272];
+    p_llrRes        = (__m256i*) &llrRes       [22272];
+            for (int i=0,j=0;i<3;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[720 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[720 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [75648];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [23424];
+    p_llrRes        = (__m256i*) &llrRes       [23424];
+            for (int i=0,j=0;i<4;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[960 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[960 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[1056 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[1056 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [94080];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [24960];
+    p_llrRes        = (__m256i*) &llrRes       [24960];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 14 CNs 
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+// Process group with <23 CNs 
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [99072];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [25344];
+    p_llrRes        = (__m256i*) &llrRes       [25344];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [109824];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [25728];
+    p_llrRes        = (__m256i*) &llrRes       [25728];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[696 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[696 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z288_R13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z288_R13_AVX2.c
new file mode 100644
index 0000000000..31c6264a07
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z288_R13_AVX2.c
@@ -0,0 +1,749 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProcPc_BG1_Z288_R13_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes,  int8_t* llrRes ,  int8_t* llrProcBuf ) {
+   __m256i ymm0, ymm1, ymmRes0, ymmRes1;  
+        __m128i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m128i* p_llrProcBuf;
+        __m256i* p_llrProcBuf256; 
+        __m256i* p_llrRes; 
+// Process group with 1 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [0];
+    p_bnProcBufRes  = (__m256i*) &bnProcBufRes [0];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [0];
+    p_llrProcBuf256 = (__m256i*) &llrProcBuf   [0];
+    p_llrRes        = (__m256i*) &llrRes       [0];
+            for (int i=0,j=0;i<378;i++,j+=2) {
+             p_bnProcBufRes[i] = p_llrProcBuf256[i];
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j+1]);
+           ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j+1]);
+            ymmRes1 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [16128];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16128];
+    p_llrRes        = (__m256i*) &llrRes       [16128];
+        for (int i=0,j=0;i<9;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [17664];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16512];
+    p_llrRes        = (__m256i*) &llrRes       [16512];
+        for (int i=0,j=0;i<9;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [19584];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16896];
+    p_llrRes        = (__m256i*) &llrRes       [16896];
+        for (int i=0,j=0;i<18;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [24192];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [17664];
+    p_llrRes        = (__m256i*) &llrRes       [17664];
+        for (int i=0,j=0;i<36;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [34944];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [19200];
+    p_llrRes        = (__m256i*) &llrRes       [19200];
+        for (int i=0,j=0;i<27;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [44160];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [20352];
+    p_llrRes        = (__m256i*) &llrRes       [20352];
+        for (int i=0,j=0;i<9;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [47616];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [20736];
+    p_llrRes        = (__m256i*) &llrRes       [20736];
+        for (int i=0,j=0;i<36;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 11 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [62976];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [22272];
+    p_llrRes        = (__m256i*) &llrRes       [22272];
+            for (int i=0,j=0;i<27;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[720 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[720 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [75648];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [23424];
+    p_llrRes        = (__m256i*) &llrRes       [23424];
+            for (int i=0,j=0;i<36;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[960 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[960 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[1056 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[1056 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [94080];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [24960];
+    p_llrRes        = (__m256i*) &llrRes       [24960];
+        for (int i=0,j=0;i<9;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 14 CNs 
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+// Process group with <23 CNs 
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [99072];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [25344];
+    p_llrRes        = (__m256i*) &llrRes       [25344];
+        for (int i=0,j=0;i<9;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [109824];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [25728];
+    p_llrRes        = (__m256i*) &llrRes       [25728];
+        for (int i=0,j=0;i<9;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[696 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[696 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z28_R13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z28_R13_AVX2.c
new file mode 100644
index 0000000000..5f261e18df
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z28_R13_AVX2.c
@@ -0,0 +1,749 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProcPc_BG1_Z28_R13_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes,  int8_t* llrRes ,  int8_t* llrProcBuf ) {
+   __m256i ymm0, ymm1, ymmRes0, ymmRes1;  
+        __m128i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m128i* p_llrProcBuf;
+        __m256i* p_llrProcBuf256; 
+        __m256i* p_llrRes; 
+// Process group with 1 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [0];
+    p_bnProcBufRes  = (__m256i*) &bnProcBufRes [0];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [0];
+    p_llrProcBuf256 = (__m256i*) &llrProcBuf   [0];
+    p_llrRes        = (__m256i*) &llrRes       [0];
+            for (int i=0,j=0;i<37;i++,j+=2) {
+             p_bnProcBufRes[i] = p_llrProcBuf256[i];
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j+1]);
+           ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j+1]);
+            ymmRes1 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [16128];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16128];
+    p_llrRes        = (__m256i*) &llrRes       [16128];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [17664];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16512];
+    p_llrRes        = (__m256i*) &llrRes       [16512];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [19584];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16896];
+    p_llrRes        = (__m256i*) &llrRes       [16896];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [24192];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [17664];
+    p_llrRes        = (__m256i*) &llrRes       [17664];
+        for (int i=0,j=0;i<4;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [34944];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [19200];
+    p_llrRes        = (__m256i*) &llrRes       [19200];
+        for (int i=0,j=0;i<3;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [44160];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [20352];
+    p_llrRes        = (__m256i*) &llrRes       [20352];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [47616];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [20736];
+    p_llrRes        = (__m256i*) &llrRes       [20736];
+        for (int i=0,j=0;i<4;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 11 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [62976];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [22272];
+    p_llrRes        = (__m256i*) &llrRes       [22272];
+            for (int i=0,j=0;i<3;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[720 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[720 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [75648];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [23424];
+    p_llrRes        = (__m256i*) &llrRes       [23424];
+            for (int i=0,j=0;i<4;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[960 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[960 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[1056 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[1056 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [94080];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [24960];
+    p_llrRes        = (__m256i*) &llrRes       [24960];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 14 CNs 
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+// Process group with <23 CNs 
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [99072];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [25344];
+    p_llrRes        = (__m256i*) &llrRes       [25344];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [109824];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [25728];
+    p_llrRes        = (__m256i*) &llrRes       [25728];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[696 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[696 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z2_R13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z2_R13_AVX2.c
new file mode 100644
index 0000000000..e77a0c287f
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z2_R13_AVX2.c
@@ -0,0 +1,749 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProcPc_BG1_Z2_R13_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes,  int8_t* llrRes ,  int8_t* llrProcBuf ) {
+   __m256i ymm0, ymm1, ymmRes0, ymmRes1;  
+        __m128i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m128i* p_llrProcBuf;
+        __m256i* p_llrProcBuf256; 
+        __m256i* p_llrRes; 
+// Process group with 1 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [0];
+    p_bnProcBufRes  = (__m256i*) &bnProcBufRes [0];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [0];
+    p_llrProcBuf256 = (__m256i*) &llrProcBuf   [0];
+    p_llrRes        = (__m256i*) &llrRes       [0];
+            for (int i=0,j=0;i<3;i++,j+=2) {
+             p_bnProcBufRes[i] = p_llrProcBuf256[i];
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j+1]);
+           ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j+1]);
+            ymmRes1 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [16128];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16128];
+    p_llrRes        = (__m256i*) &llrRes       [16128];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [17664];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16512];
+    p_llrRes        = (__m256i*) &llrRes       [16512];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [19584];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16896];
+    p_llrRes        = (__m256i*) &llrRes       [16896];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [24192];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [17664];
+    p_llrRes        = (__m256i*) &llrRes       [17664];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [34944];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [19200];
+    p_llrRes        = (__m256i*) &llrRes       [19200];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [44160];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [20352];
+    p_llrRes        = (__m256i*) &llrRes       [20352];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [47616];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [20736];
+    p_llrRes        = (__m256i*) &llrRes       [20736];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 11 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [62976];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [22272];
+    p_llrRes        = (__m256i*) &llrRes       [22272];
+            for (int i=0,j=0;i<1;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[720 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[720 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [75648];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [23424];
+    p_llrRes        = (__m256i*) &llrRes       [23424];
+            for (int i=0,j=0;i<1;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[960 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[960 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[1056 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[1056 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [94080];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [24960];
+    p_llrRes        = (__m256i*) &llrRes       [24960];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 14 CNs 
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+// Process group with <23 CNs 
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [99072];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [25344];
+    p_llrRes        = (__m256i*) &llrRes       [25344];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [109824];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [25728];
+    p_llrRes        = (__m256i*) &llrRes       [25728];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[696 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[696 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z30_R13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z30_R13_AVX2.c
new file mode 100644
index 0000000000..9c40d68946
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z30_R13_AVX2.c
@@ -0,0 +1,749 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProcPc_BG1_Z30_R13_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes,  int8_t* llrRes ,  int8_t* llrProcBuf ) {
+   __m256i ymm0, ymm1, ymmRes0, ymmRes1;  
+        __m128i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m128i* p_llrProcBuf;
+        __m256i* p_llrProcBuf256; 
+        __m256i* p_llrRes; 
+// Process group with 1 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [0];
+    p_bnProcBufRes  = (__m256i*) &bnProcBufRes [0];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [0];
+    p_llrProcBuf256 = (__m256i*) &llrProcBuf   [0];
+    p_llrRes        = (__m256i*) &llrRes       [0];
+            for (int i=0,j=0;i<40;i++,j+=2) {
+             p_bnProcBufRes[i] = p_llrProcBuf256[i];
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j+1]);
+           ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j+1]);
+            ymmRes1 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [16128];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16128];
+    p_llrRes        = (__m256i*) &llrRes       [16128];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [17664];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16512];
+    p_llrRes        = (__m256i*) &llrRes       [16512];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [19584];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16896];
+    p_llrRes        = (__m256i*) &llrRes       [16896];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [24192];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [17664];
+    p_llrRes        = (__m256i*) &llrRes       [17664];
+        for (int i=0,j=0;i<4;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [34944];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [19200];
+    p_llrRes        = (__m256i*) &llrRes       [19200];
+        for (int i=0,j=0;i<3;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [44160];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [20352];
+    p_llrRes        = (__m256i*) &llrRes       [20352];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [47616];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [20736];
+    p_llrRes        = (__m256i*) &llrRes       [20736];
+        for (int i=0,j=0;i<4;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 11 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [62976];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [22272];
+    p_llrRes        = (__m256i*) &llrRes       [22272];
+            for (int i=0,j=0;i<3;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[720 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[720 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [75648];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [23424];
+    p_llrRes        = (__m256i*) &llrRes       [23424];
+            for (int i=0,j=0;i<4;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[960 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[960 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[1056 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[1056 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [94080];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [24960];
+    p_llrRes        = (__m256i*) &llrRes       [24960];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 14 CNs 
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+// Process group with <23 CNs 
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [99072];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [25344];
+    p_llrRes        = (__m256i*) &llrRes       [25344];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [109824];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [25728];
+    p_llrRes        = (__m256i*) &llrRes       [25728];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[696 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[696 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z320_R13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z320_R13_AVX2.c
new file mode 100644
index 0000000000..ad6d124bae
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z320_R13_AVX2.c
@@ -0,0 +1,749 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProcPc_BG1_Z320_R13_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes,  int8_t* llrRes ,  int8_t* llrProcBuf ) {
+   __m256i ymm0, ymm1, ymmRes0, ymmRes1;  
+        __m128i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m128i* p_llrProcBuf;
+        __m256i* p_llrProcBuf256; 
+        __m256i* p_llrRes; 
+// Process group with 1 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [0];
+    p_bnProcBufRes  = (__m256i*) &bnProcBufRes [0];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [0];
+    p_llrProcBuf256 = (__m256i*) &llrProcBuf   [0];
+    p_llrRes        = (__m256i*) &llrRes       [0];
+            for (int i=0,j=0;i<420;i++,j+=2) {
+             p_bnProcBufRes[i] = p_llrProcBuf256[i];
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j+1]);
+           ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j+1]);
+            ymmRes1 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [16128];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16128];
+    p_llrRes        = (__m256i*) &llrRes       [16128];
+        for (int i=0,j=0;i<10;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [17664];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16512];
+    p_llrRes        = (__m256i*) &llrRes       [16512];
+        for (int i=0,j=0;i<10;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [19584];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16896];
+    p_llrRes        = (__m256i*) &llrRes       [16896];
+        for (int i=0,j=0;i<20;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [24192];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [17664];
+    p_llrRes        = (__m256i*) &llrRes       [17664];
+        for (int i=0,j=0;i<40;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [34944];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [19200];
+    p_llrRes        = (__m256i*) &llrRes       [19200];
+        for (int i=0,j=0;i<30;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [44160];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [20352];
+    p_llrRes        = (__m256i*) &llrRes       [20352];
+        for (int i=0,j=0;i<10;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [47616];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [20736];
+    p_llrRes        = (__m256i*) &llrRes       [20736];
+        for (int i=0,j=0;i<40;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 11 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [62976];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [22272];
+    p_llrRes        = (__m256i*) &llrRes       [22272];
+            for (int i=0,j=0;i<30;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[720 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[720 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [75648];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [23424];
+    p_llrRes        = (__m256i*) &llrRes       [23424];
+            for (int i=0,j=0;i<40;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[960 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[960 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[1056 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[1056 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [94080];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [24960];
+    p_llrRes        = (__m256i*) &llrRes       [24960];
+        for (int i=0,j=0;i<10;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 14 CNs 
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+// Process group with <23 CNs 
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [99072];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [25344];
+    p_llrRes        = (__m256i*) &llrRes       [25344];
+        for (int i=0,j=0;i<10;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [109824];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [25728];
+    p_llrRes        = (__m256i*) &llrRes       [25728];
+        for (int i=0,j=0;i<10;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[696 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[696 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z32_R13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z32_R13_AVX2.c
new file mode 100644
index 0000000000..57401cbf41
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z32_R13_AVX2.c
@@ -0,0 +1,749 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProcPc_BG1_Z32_R13_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes,  int8_t* llrRes ,  int8_t* llrProcBuf ) {
+   __m256i ymm0, ymm1, ymmRes0, ymmRes1;  
+        __m128i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m128i* p_llrProcBuf;
+        __m256i* p_llrProcBuf256; 
+        __m256i* p_llrRes; 
+// Process group with 1 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [0];
+    p_bnProcBufRes  = (__m256i*) &bnProcBufRes [0];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [0];
+    p_llrProcBuf256 = (__m256i*) &llrProcBuf   [0];
+    p_llrRes        = (__m256i*) &llrRes       [0];
+            for (int i=0,j=0;i<42;i++,j+=2) {
+             p_bnProcBufRes[i] = p_llrProcBuf256[i];
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j+1]);
+           ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j+1]);
+            ymmRes1 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [16128];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16128];
+    p_llrRes        = (__m256i*) &llrRes       [16128];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [17664];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16512];
+    p_llrRes        = (__m256i*) &llrRes       [16512];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [19584];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16896];
+    p_llrRes        = (__m256i*) &llrRes       [16896];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [24192];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [17664];
+    p_llrRes        = (__m256i*) &llrRes       [17664];
+        for (int i=0,j=0;i<4;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [34944];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [19200];
+    p_llrRes        = (__m256i*) &llrRes       [19200];
+        for (int i=0,j=0;i<3;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [44160];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [20352];
+    p_llrRes        = (__m256i*) &llrRes       [20352];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [47616];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [20736];
+    p_llrRes        = (__m256i*) &llrRes       [20736];
+        for (int i=0,j=0;i<4;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 11 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [62976];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [22272];
+    p_llrRes        = (__m256i*) &llrRes       [22272];
+            for (int i=0,j=0;i<3;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[720 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[720 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [75648];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [23424];
+    p_llrRes        = (__m256i*) &llrRes       [23424];
+            for (int i=0,j=0;i<4;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[960 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[960 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[1056 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[1056 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [94080];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [24960];
+    p_llrRes        = (__m256i*) &llrRes       [24960];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 14 CNs 
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+// Process group with <23 CNs 
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [99072];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [25344];
+    p_llrRes        = (__m256i*) &llrRes       [25344];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [109824];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [25728];
+    p_llrRes        = (__m256i*) &llrRes       [25728];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[696 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[696 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z352_R13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z352_R13_AVX2.c
new file mode 100644
index 0000000000..901bc03cd9
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z352_R13_AVX2.c
@@ -0,0 +1,749 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProcPc_BG1_Z352_R13_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes,  int8_t* llrRes ,  int8_t* llrProcBuf ) {
+   __m256i ymm0, ymm1, ymmRes0, ymmRes1;  
+        __m128i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m128i* p_llrProcBuf;
+        __m256i* p_llrProcBuf256; 
+        __m256i* p_llrRes; 
+// Process group with 1 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [0];
+    p_bnProcBufRes  = (__m256i*) &bnProcBufRes [0];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [0];
+    p_llrProcBuf256 = (__m256i*) &llrProcBuf   [0];
+    p_llrRes        = (__m256i*) &llrRes       [0];
+            for (int i=0,j=0;i<462;i++,j+=2) {
+             p_bnProcBufRes[i] = p_llrProcBuf256[i];
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j+1]);
+           ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j+1]);
+            ymmRes1 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [16128];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16128];
+    p_llrRes        = (__m256i*) &llrRes       [16128];
+        for (int i=0,j=0;i<11;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [17664];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16512];
+    p_llrRes        = (__m256i*) &llrRes       [16512];
+        for (int i=0,j=0;i<11;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [19584];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16896];
+    p_llrRes        = (__m256i*) &llrRes       [16896];
+        for (int i=0,j=0;i<22;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [24192];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [17664];
+    p_llrRes        = (__m256i*) &llrRes       [17664];
+        for (int i=0,j=0;i<44;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [34944];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [19200];
+    p_llrRes        = (__m256i*) &llrRes       [19200];
+        for (int i=0,j=0;i<33;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [44160];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [20352];
+    p_llrRes        = (__m256i*) &llrRes       [20352];
+        for (int i=0,j=0;i<11;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [47616];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [20736];
+    p_llrRes        = (__m256i*) &llrRes       [20736];
+        for (int i=0,j=0;i<44;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 11 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [62976];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [22272];
+    p_llrRes        = (__m256i*) &llrRes       [22272];
+            for (int i=0,j=0;i<33;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[720 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[720 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [75648];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [23424];
+    p_llrRes        = (__m256i*) &llrRes       [23424];
+            for (int i=0,j=0;i<44;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[960 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[960 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[1056 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[1056 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [94080];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [24960];
+    p_llrRes        = (__m256i*) &llrRes       [24960];
+        for (int i=0,j=0;i<11;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 14 CNs 
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+// Process group with <23 CNs 
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [99072];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [25344];
+    p_llrRes        = (__m256i*) &llrRes       [25344];
+        for (int i=0,j=0;i<11;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [109824];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [25728];
+    p_llrRes        = (__m256i*) &llrRes       [25728];
+        for (int i=0,j=0;i<11;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[696 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[696 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z36_R13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z36_R13_AVX2.c
new file mode 100644
index 0000000000..4799b8efbf
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z36_R13_AVX2.c
@@ -0,0 +1,749 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProcPc_BG1_Z36_R13_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes,  int8_t* llrRes ,  int8_t* llrProcBuf ) {
+   __m256i ymm0, ymm1, ymmRes0, ymmRes1;  
+        __m128i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m128i* p_llrProcBuf;
+        __m256i* p_llrProcBuf256; 
+        __m256i* p_llrRes; 
+// Process group with 1 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [0];
+    p_bnProcBufRes  = (__m256i*) &bnProcBufRes [0];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [0];
+    p_llrProcBuf256 = (__m256i*) &llrProcBuf   [0];
+    p_llrRes        = (__m256i*) &llrRes       [0];
+            for (int i=0,j=0;i<48;i++,j+=2) {
+             p_bnProcBufRes[i] = p_llrProcBuf256[i];
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j+1]);
+           ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j+1]);
+            ymmRes1 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [16128];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16128];
+    p_llrRes        = (__m256i*) &llrRes       [16128];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [17664];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16512];
+    p_llrRes        = (__m256i*) &llrRes       [16512];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [19584];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16896];
+    p_llrRes        = (__m256i*) &llrRes       [16896];
+        for (int i=0,j=0;i<3;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [24192];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [17664];
+    p_llrRes        = (__m256i*) &llrRes       [17664];
+        for (int i=0,j=0;i<5;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [34944];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [19200];
+    p_llrRes        = (__m256i*) &llrRes       [19200];
+        for (int i=0,j=0;i<4;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [44160];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [20352];
+    p_llrRes        = (__m256i*) &llrRes       [20352];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [47616];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [20736];
+    p_llrRes        = (__m256i*) &llrRes       [20736];
+        for (int i=0,j=0;i<5;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 11 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [62976];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [22272];
+    p_llrRes        = (__m256i*) &llrRes       [22272];
+            for (int i=0,j=0;i<4;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[720 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[720 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [75648];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [23424];
+    p_llrRes        = (__m256i*) &llrRes       [23424];
+            for (int i=0,j=0;i<5;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[960 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[960 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[1056 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[1056 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [94080];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [24960];
+    p_llrRes        = (__m256i*) &llrRes       [24960];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 14 CNs 
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+// Process group with <23 CNs 
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [99072];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [25344];
+    p_llrRes        = (__m256i*) &llrRes       [25344];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [109824];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [25728];
+    p_llrRes        = (__m256i*) &llrRes       [25728];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[696 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[696 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z384_R13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z384_R13_AVX2.c
new file mode 100644
index 0000000000..bccdf09c1e
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z384_R13_AVX2.c
@@ -0,0 +1,749 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProcPc_BG1_Z384_R13_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes,  int8_t* llrRes ,  int8_t* llrProcBuf ) {
+   __m256i ymm0, ymm1, ymmRes0, ymmRes1;  
+        __m128i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m128i* p_llrProcBuf;
+        __m256i* p_llrProcBuf256; 
+        __m256i* p_llrRes; 
+// Process group with 1 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [0];
+    p_bnProcBufRes  = (__m256i*) &bnProcBufRes [0];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [0];
+    p_llrProcBuf256 = (__m256i*) &llrProcBuf   [0];
+    p_llrRes        = (__m256i*) &llrRes       [0];
+            for (int i=0,j=0;i<504;i++,j+=2) {
+             p_bnProcBufRes[i] = p_llrProcBuf256[i];
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j+1]);
+           ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j+1]);
+            ymmRes1 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [16128];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16128];
+    p_llrRes        = (__m256i*) &llrRes       [16128];
+        for (int i=0,j=0;i<12;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [17664];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16512];
+    p_llrRes        = (__m256i*) &llrRes       [16512];
+        for (int i=0,j=0;i<12;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [19584];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16896];
+    p_llrRes        = (__m256i*) &llrRes       [16896];
+        for (int i=0,j=0;i<24;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [24192];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [17664];
+    p_llrRes        = (__m256i*) &llrRes       [17664];
+        for (int i=0,j=0;i<48;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [34944];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [19200];
+    p_llrRes        = (__m256i*) &llrRes       [19200];
+        for (int i=0,j=0;i<36;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [44160];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [20352];
+    p_llrRes        = (__m256i*) &llrRes       [20352];
+        for (int i=0,j=0;i<12;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [47616];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [20736];
+    p_llrRes        = (__m256i*) &llrRes       [20736];
+        for (int i=0,j=0;i<48;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 11 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [62976];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [22272];
+    p_llrRes        = (__m256i*) &llrRes       [22272];
+            for (int i=0,j=0;i<36;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[720 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[720 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [75648];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [23424];
+    p_llrRes        = (__m256i*) &llrRes       [23424];
+            for (int i=0,j=0;i<48;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[960 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[960 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[1056 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[1056 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [94080];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [24960];
+    p_llrRes        = (__m256i*) &llrRes       [24960];
+        for (int i=0,j=0;i<12;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 14 CNs 
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+// Process group with <23 CNs 
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [99072];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [25344];
+    p_llrRes        = (__m256i*) &llrRes       [25344];
+        for (int i=0,j=0;i<12;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [109824];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [25728];
+    p_llrRes        = (__m256i*) &llrRes       [25728];
+        for (int i=0,j=0;i<12;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[696 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[696 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z3_R13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z3_R13_AVX2.c
new file mode 100644
index 0000000000..a458247cf1
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z3_R13_AVX2.c
@@ -0,0 +1,749 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProcPc_BG1_Z3_R13_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes,  int8_t* llrRes ,  int8_t* llrProcBuf ) {
+   __m256i ymm0, ymm1, ymmRes0, ymmRes1;  
+        __m128i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m128i* p_llrProcBuf;
+        __m256i* p_llrProcBuf256; 
+        __m256i* p_llrRes; 
+// Process group with 1 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [0];
+    p_bnProcBufRes  = (__m256i*) &bnProcBufRes [0];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [0];
+    p_llrProcBuf256 = (__m256i*) &llrProcBuf   [0];
+    p_llrRes        = (__m256i*) &llrRes       [0];
+            for (int i=0,j=0;i<4;i++,j+=2) {
+             p_bnProcBufRes[i] = p_llrProcBuf256[i];
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j+1]);
+           ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j+1]);
+            ymmRes1 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [16128];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16128];
+    p_llrRes        = (__m256i*) &llrRes       [16128];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [17664];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16512];
+    p_llrRes        = (__m256i*) &llrRes       [16512];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [19584];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16896];
+    p_llrRes        = (__m256i*) &llrRes       [16896];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [24192];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [17664];
+    p_llrRes        = (__m256i*) &llrRes       [17664];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [34944];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [19200];
+    p_llrRes        = (__m256i*) &llrRes       [19200];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [44160];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [20352];
+    p_llrRes        = (__m256i*) &llrRes       [20352];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [47616];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [20736];
+    p_llrRes        = (__m256i*) &llrRes       [20736];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 11 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [62976];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [22272];
+    p_llrRes        = (__m256i*) &llrRes       [22272];
+            for (int i=0,j=0;i<1;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[720 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[720 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [75648];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [23424];
+    p_llrRes        = (__m256i*) &llrRes       [23424];
+            for (int i=0,j=0;i<1;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[960 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[960 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[1056 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[1056 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [94080];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [24960];
+    p_llrRes        = (__m256i*) &llrRes       [24960];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 14 CNs 
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+// Process group with <23 CNs 
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [99072];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [25344];
+    p_llrRes        = (__m256i*) &llrRes       [25344];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [109824];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [25728];
+    p_llrRes        = (__m256i*) &llrRes       [25728];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[696 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[696 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z40_R13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z40_R13_AVX2.c
new file mode 100644
index 0000000000..79d4f4ae71
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z40_R13_AVX2.c
@@ -0,0 +1,749 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProcPc_BG1_Z40_R13_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes,  int8_t* llrRes ,  int8_t* llrProcBuf ) {
+   __m256i ymm0, ymm1, ymmRes0, ymmRes1;  
+        __m128i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m128i* p_llrProcBuf;
+        __m256i* p_llrProcBuf256; 
+        __m256i* p_llrRes; 
+// Process group with 1 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [0];
+    p_bnProcBufRes  = (__m256i*) &bnProcBufRes [0];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [0];
+    p_llrProcBuf256 = (__m256i*) &llrProcBuf   [0];
+    p_llrRes        = (__m256i*) &llrRes       [0];
+            for (int i=0,j=0;i<53;i++,j+=2) {
+             p_bnProcBufRes[i] = p_llrProcBuf256[i];
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j+1]);
+           ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j+1]);
+            ymmRes1 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [16128];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16128];
+    p_llrRes        = (__m256i*) &llrRes       [16128];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [17664];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16512];
+    p_llrRes        = (__m256i*) &llrRes       [16512];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [19584];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16896];
+    p_llrRes        = (__m256i*) &llrRes       [16896];
+        for (int i=0,j=0;i<3;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [24192];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [17664];
+    p_llrRes        = (__m256i*) &llrRes       [17664];
+        for (int i=0,j=0;i<5;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [34944];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [19200];
+    p_llrRes        = (__m256i*) &llrRes       [19200];
+        for (int i=0,j=0;i<4;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [44160];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [20352];
+    p_llrRes        = (__m256i*) &llrRes       [20352];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [47616];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [20736];
+    p_llrRes        = (__m256i*) &llrRes       [20736];
+        for (int i=0,j=0;i<5;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 11 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [62976];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [22272];
+    p_llrRes        = (__m256i*) &llrRes       [22272];
+            for (int i=0,j=0;i<4;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[720 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[720 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [75648];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [23424];
+    p_llrRes        = (__m256i*) &llrRes       [23424];
+            for (int i=0,j=0;i<5;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[960 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[960 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[1056 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[1056 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [94080];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [24960];
+    p_llrRes        = (__m256i*) &llrRes       [24960];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 14 CNs 
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+// Process group with <23 CNs 
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [99072];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [25344];
+    p_llrRes        = (__m256i*) &llrRes       [25344];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [109824];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [25728];
+    p_llrRes        = (__m256i*) &llrRes       [25728];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[696 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[696 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z44_R13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z44_R13_AVX2.c
new file mode 100644
index 0000000000..5e91ecb0c1
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z44_R13_AVX2.c
@@ -0,0 +1,749 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProcPc_BG1_Z44_R13_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes,  int8_t* llrRes ,  int8_t* llrProcBuf ) {
+   __m256i ymm0, ymm1, ymmRes0, ymmRes1;  
+        __m128i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m128i* p_llrProcBuf;
+        __m256i* p_llrProcBuf256; 
+        __m256i* p_llrRes; 
+// Process group with 1 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [0];
+    p_bnProcBufRes  = (__m256i*) &bnProcBufRes [0];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [0];
+    p_llrProcBuf256 = (__m256i*) &llrProcBuf   [0];
+    p_llrRes        = (__m256i*) &llrRes       [0];
+            for (int i=0,j=0;i<58;i++,j+=2) {
+             p_bnProcBufRes[i] = p_llrProcBuf256[i];
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j+1]);
+           ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j+1]);
+            ymmRes1 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [16128];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16128];
+    p_llrRes        = (__m256i*) &llrRes       [16128];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [17664];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16512];
+    p_llrRes        = (__m256i*) &llrRes       [16512];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [19584];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16896];
+    p_llrRes        = (__m256i*) &llrRes       [16896];
+        for (int i=0,j=0;i<3;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [24192];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [17664];
+    p_llrRes        = (__m256i*) &llrRes       [17664];
+        for (int i=0,j=0;i<6;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [34944];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [19200];
+    p_llrRes        = (__m256i*) &llrRes       [19200];
+        for (int i=0,j=0;i<5;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [44160];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [20352];
+    p_llrRes        = (__m256i*) &llrRes       [20352];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [47616];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [20736];
+    p_llrRes        = (__m256i*) &llrRes       [20736];
+        for (int i=0,j=0;i<6;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 11 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [62976];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [22272];
+    p_llrRes        = (__m256i*) &llrRes       [22272];
+            for (int i=0,j=0;i<5;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[720 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[720 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [75648];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [23424];
+    p_llrRes        = (__m256i*) &llrRes       [23424];
+            for (int i=0,j=0;i<6;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[960 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[960 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[1056 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[1056 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [94080];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [24960];
+    p_llrRes        = (__m256i*) &llrRes       [24960];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 14 CNs 
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+// Process group with <23 CNs 
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [99072];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [25344];
+    p_llrRes        = (__m256i*) &llrRes       [25344];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [109824];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [25728];
+    p_llrRes        = (__m256i*) &llrRes       [25728];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[696 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[696 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z48_R13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z48_R13_AVX2.c
new file mode 100644
index 0000000000..7e7af0c1ce
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z48_R13_AVX2.c
@@ -0,0 +1,749 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProcPc_BG1_Z48_R13_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes,  int8_t* llrRes ,  int8_t* llrProcBuf ) {
+   __m256i ymm0, ymm1, ymmRes0, ymmRes1;  
+        __m128i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m128i* p_llrProcBuf;
+        __m256i* p_llrProcBuf256; 
+        __m256i* p_llrRes; 
+// Process group with 1 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [0];
+    p_bnProcBufRes  = (__m256i*) &bnProcBufRes [0];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [0];
+    p_llrProcBuf256 = (__m256i*) &llrProcBuf   [0];
+    p_llrRes        = (__m256i*) &llrRes       [0];
+            for (int i=0,j=0;i<63;i++,j+=2) {
+             p_bnProcBufRes[i] = p_llrProcBuf256[i];
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j+1]);
+           ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j+1]);
+            ymmRes1 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [16128];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16128];
+    p_llrRes        = (__m256i*) &llrRes       [16128];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [17664];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16512];
+    p_llrRes        = (__m256i*) &llrRes       [16512];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [19584];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16896];
+    p_llrRes        = (__m256i*) &llrRes       [16896];
+        for (int i=0,j=0;i<3;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [24192];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [17664];
+    p_llrRes        = (__m256i*) &llrRes       [17664];
+        for (int i=0,j=0;i<6;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [34944];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [19200];
+    p_llrRes        = (__m256i*) &llrRes       [19200];
+        for (int i=0,j=0;i<5;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [44160];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [20352];
+    p_llrRes        = (__m256i*) &llrRes       [20352];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [47616];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [20736];
+    p_llrRes        = (__m256i*) &llrRes       [20736];
+        for (int i=0,j=0;i<6;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 11 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [62976];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [22272];
+    p_llrRes        = (__m256i*) &llrRes       [22272];
+            for (int i=0,j=0;i<5;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[720 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[720 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [75648];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [23424];
+    p_llrRes        = (__m256i*) &llrRes       [23424];
+            for (int i=0,j=0;i<6;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[960 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[960 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[1056 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[1056 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [94080];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [24960];
+    p_llrRes        = (__m256i*) &llrRes       [24960];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 14 CNs 
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+// Process group with <23 CNs 
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [99072];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [25344];
+    p_llrRes        = (__m256i*) &llrRes       [25344];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [109824];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [25728];
+    p_llrRes        = (__m256i*) &llrRes       [25728];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[696 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[696 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z4_R13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z4_R13_AVX2.c
new file mode 100644
index 0000000000..06e7bc8467
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z4_R13_AVX2.c
@@ -0,0 +1,749 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProcPc_BG1_Z4_R13_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes,  int8_t* llrRes ,  int8_t* llrProcBuf ) {
+   __m256i ymm0, ymm1, ymmRes0, ymmRes1;  
+        __m128i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m128i* p_llrProcBuf;
+        __m256i* p_llrProcBuf256; 
+        __m256i* p_llrRes; 
+// Process group with 1 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [0];
+    p_bnProcBufRes  = (__m256i*) &bnProcBufRes [0];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [0];
+    p_llrProcBuf256 = (__m256i*) &llrProcBuf   [0];
+    p_llrRes        = (__m256i*) &llrRes       [0];
+            for (int i=0,j=0;i<6;i++,j+=2) {
+             p_bnProcBufRes[i] = p_llrProcBuf256[i];
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j+1]);
+           ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j+1]);
+            ymmRes1 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [16128];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16128];
+    p_llrRes        = (__m256i*) &llrRes       [16128];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [17664];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16512];
+    p_llrRes        = (__m256i*) &llrRes       [16512];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [19584];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16896];
+    p_llrRes        = (__m256i*) &llrRes       [16896];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [24192];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [17664];
+    p_llrRes        = (__m256i*) &llrRes       [17664];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [34944];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [19200];
+    p_llrRes        = (__m256i*) &llrRes       [19200];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [44160];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [20352];
+    p_llrRes        = (__m256i*) &llrRes       [20352];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [47616];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [20736];
+    p_llrRes        = (__m256i*) &llrRes       [20736];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 11 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [62976];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [22272];
+    p_llrRes        = (__m256i*) &llrRes       [22272];
+            for (int i=0,j=0;i<1;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[720 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[720 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [75648];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [23424];
+    p_llrRes        = (__m256i*) &llrRes       [23424];
+            for (int i=0,j=0;i<1;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[960 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[960 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[1056 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[1056 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [94080];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [24960];
+    p_llrRes        = (__m256i*) &llrRes       [24960];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 14 CNs 
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+// Process group with <23 CNs 
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [99072];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [25344];
+    p_llrRes        = (__m256i*) &llrRes       [25344];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [109824];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [25728];
+    p_llrRes        = (__m256i*) &llrRes       [25728];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[696 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[696 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z52_R13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z52_R13_AVX2.c
new file mode 100644
index 0000000000..6954acb650
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z52_R13_AVX2.c
@@ -0,0 +1,749 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProcPc_BG1_Z52_R13_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes,  int8_t* llrRes ,  int8_t* llrProcBuf ) {
+   __m256i ymm0, ymm1, ymmRes0, ymmRes1;  
+        __m128i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m128i* p_llrProcBuf;
+        __m256i* p_llrProcBuf256; 
+        __m256i* p_llrRes; 
+// Process group with 1 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [0];
+    p_bnProcBufRes  = (__m256i*) &bnProcBufRes [0];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [0];
+    p_llrProcBuf256 = (__m256i*) &llrProcBuf   [0];
+    p_llrRes        = (__m256i*) &llrRes       [0];
+            for (int i=0,j=0;i<69;i++,j+=2) {
+             p_bnProcBufRes[i] = p_llrProcBuf256[i];
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j+1]);
+           ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j+1]);
+            ymmRes1 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [16128];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16128];
+    p_llrRes        = (__m256i*) &llrRes       [16128];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [17664];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16512];
+    p_llrRes        = (__m256i*) &llrRes       [16512];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [19584];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16896];
+    p_llrRes        = (__m256i*) &llrRes       [16896];
+        for (int i=0,j=0;i<4;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [24192];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [17664];
+    p_llrRes        = (__m256i*) &llrRes       [17664];
+        for (int i=0,j=0;i<7;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [34944];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [19200];
+    p_llrRes        = (__m256i*) &llrRes       [19200];
+        for (int i=0,j=0;i<5;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [44160];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [20352];
+    p_llrRes        = (__m256i*) &llrRes       [20352];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [47616];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [20736];
+    p_llrRes        = (__m256i*) &llrRes       [20736];
+        for (int i=0,j=0;i<7;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 11 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [62976];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [22272];
+    p_llrRes        = (__m256i*) &llrRes       [22272];
+            for (int i=0,j=0;i<5;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[720 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[720 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [75648];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [23424];
+    p_llrRes        = (__m256i*) &llrRes       [23424];
+            for (int i=0,j=0;i<7;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[960 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[960 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[1056 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[1056 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [94080];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [24960];
+    p_llrRes        = (__m256i*) &llrRes       [24960];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 14 CNs 
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+// Process group with <23 CNs 
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [99072];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [25344];
+    p_llrRes        = (__m256i*) &llrRes       [25344];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [109824];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [25728];
+    p_llrRes        = (__m256i*) &llrRes       [25728];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[696 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[696 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z56_R13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z56_R13_AVX2.c
new file mode 100644
index 0000000000..dd4d169cb2
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z56_R13_AVX2.c
@@ -0,0 +1,749 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProcPc_BG1_Z56_R13_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes,  int8_t* llrRes ,  int8_t* llrProcBuf ) {
+   __m256i ymm0, ymm1, ymmRes0, ymmRes1;  
+        __m128i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m128i* p_llrProcBuf;
+        __m256i* p_llrProcBuf256; 
+        __m256i* p_llrRes; 
+// Process group with 1 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [0];
+    p_bnProcBufRes  = (__m256i*) &bnProcBufRes [0];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [0];
+    p_llrProcBuf256 = (__m256i*) &llrProcBuf   [0];
+    p_llrRes        = (__m256i*) &llrRes       [0];
+            for (int i=0,j=0;i<74;i++,j+=2) {
+             p_bnProcBufRes[i] = p_llrProcBuf256[i];
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j+1]);
+           ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j+1]);
+            ymmRes1 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [16128];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16128];
+    p_llrRes        = (__m256i*) &llrRes       [16128];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [17664];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16512];
+    p_llrRes        = (__m256i*) &llrRes       [16512];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [19584];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16896];
+    p_llrRes        = (__m256i*) &llrRes       [16896];
+        for (int i=0,j=0;i<4;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [24192];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [17664];
+    p_llrRes        = (__m256i*) &llrRes       [17664];
+        for (int i=0,j=0;i<7;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [34944];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [19200];
+    p_llrRes        = (__m256i*) &llrRes       [19200];
+        for (int i=0,j=0;i<6;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [44160];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [20352];
+    p_llrRes        = (__m256i*) &llrRes       [20352];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [47616];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [20736];
+    p_llrRes        = (__m256i*) &llrRes       [20736];
+        for (int i=0,j=0;i<7;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 11 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [62976];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [22272];
+    p_llrRes        = (__m256i*) &llrRes       [22272];
+            for (int i=0,j=0;i<6;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[720 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[720 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [75648];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [23424];
+    p_llrRes        = (__m256i*) &llrRes       [23424];
+            for (int i=0,j=0;i<7;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[960 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[960 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[1056 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[1056 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [94080];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [24960];
+    p_llrRes        = (__m256i*) &llrRes       [24960];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 14 CNs 
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+// Process group with <23 CNs 
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [99072];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [25344];
+    p_llrRes        = (__m256i*) &llrRes       [25344];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [109824];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [25728];
+    p_llrRes        = (__m256i*) &llrRes       [25728];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[696 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[696 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z5_R13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z5_R13_AVX2.c
new file mode 100644
index 0000000000..c3943c0003
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z5_R13_AVX2.c
@@ -0,0 +1,749 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProcPc_BG1_Z5_R13_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes,  int8_t* llrRes ,  int8_t* llrProcBuf ) {
+   __m256i ymm0, ymm1, ymmRes0, ymmRes1;  
+        __m128i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m128i* p_llrProcBuf;
+        __m256i* p_llrProcBuf256; 
+        __m256i* p_llrRes; 
+// Process group with 1 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [0];
+    p_bnProcBufRes  = (__m256i*) &bnProcBufRes [0];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [0];
+    p_llrProcBuf256 = (__m256i*) &llrProcBuf   [0];
+    p_llrRes        = (__m256i*) &llrRes       [0];
+            for (int i=0,j=0;i<7;i++,j+=2) {
+             p_bnProcBufRes[i] = p_llrProcBuf256[i];
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j+1]);
+           ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j+1]);
+            ymmRes1 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [16128];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16128];
+    p_llrRes        = (__m256i*) &llrRes       [16128];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [17664];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16512];
+    p_llrRes        = (__m256i*) &llrRes       [16512];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [19584];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16896];
+    p_llrRes        = (__m256i*) &llrRes       [16896];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [24192];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [17664];
+    p_llrRes        = (__m256i*) &llrRes       [17664];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [34944];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [19200];
+    p_llrRes        = (__m256i*) &llrRes       [19200];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [44160];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [20352];
+    p_llrRes        = (__m256i*) &llrRes       [20352];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [47616];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [20736];
+    p_llrRes        = (__m256i*) &llrRes       [20736];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 11 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [62976];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [22272];
+    p_llrRes        = (__m256i*) &llrRes       [22272];
+            for (int i=0,j=0;i<1;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[720 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[720 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [75648];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [23424];
+    p_llrRes        = (__m256i*) &llrRes       [23424];
+            for (int i=0,j=0;i<1;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[960 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[960 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[1056 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[1056 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [94080];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [24960];
+    p_llrRes        = (__m256i*) &llrRes       [24960];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 14 CNs 
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+// Process group with <23 CNs 
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [99072];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [25344];
+    p_llrRes        = (__m256i*) &llrRes       [25344];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [109824];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [25728];
+    p_llrRes        = (__m256i*) &llrRes       [25728];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[696 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[696 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z60_R13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z60_R13_AVX2.c
new file mode 100644
index 0000000000..cd4c7ff1b9
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z60_R13_AVX2.c
@@ -0,0 +1,749 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProcPc_BG1_Z60_R13_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes,  int8_t* llrRes ,  int8_t* llrProcBuf ) {
+   __m256i ymm0, ymm1, ymmRes0, ymmRes1;  
+        __m128i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m128i* p_llrProcBuf;
+        __m256i* p_llrProcBuf256; 
+        __m256i* p_llrRes; 
+// Process group with 1 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [0];
+    p_bnProcBufRes  = (__m256i*) &bnProcBufRes [0];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [0];
+    p_llrProcBuf256 = (__m256i*) &llrProcBuf   [0];
+    p_llrRes        = (__m256i*) &llrRes       [0];
+            for (int i=0,j=0;i<79;i++,j+=2) {
+             p_bnProcBufRes[i] = p_llrProcBuf256[i];
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j+1]);
+           ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j+1]);
+            ymmRes1 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [16128];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16128];
+    p_llrRes        = (__m256i*) &llrRes       [16128];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [17664];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16512];
+    p_llrRes        = (__m256i*) &llrRes       [16512];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [19584];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16896];
+    p_llrRes        = (__m256i*) &llrRes       [16896];
+        for (int i=0,j=0;i<4;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [24192];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [17664];
+    p_llrRes        = (__m256i*) &llrRes       [17664];
+        for (int i=0,j=0;i<8;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [34944];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [19200];
+    p_llrRes        = (__m256i*) &llrRes       [19200];
+        for (int i=0,j=0;i<6;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [44160];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [20352];
+    p_llrRes        = (__m256i*) &llrRes       [20352];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [47616];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [20736];
+    p_llrRes        = (__m256i*) &llrRes       [20736];
+        for (int i=0,j=0;i<8;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 11 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [62976];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [22272];
+    p_llrRes        = (__m256i*) &llrRes       [22272];
+            for (int i=0,j=0;i<6;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[720 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[720 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [75648];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [23424];
+    p_llrRes        = (__m256i*) &llrRes       [23424];
+            for (int i=0,j=0;i<8;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[960 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[960 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[1056 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[1056 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [94080];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [24960];
+    p_llrRes        = (__m256i*) &llrRes       [24960];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 14 CNs 
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+// Process group with <23 CNs 
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [99072];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [25344];
+    p_llrRes        = (__m256i*) &llrRes       [25344];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [109824];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [25728];
+    p_llrRes        = (__m256i*) &llrRes       [25728];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[696 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[696 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z64_R13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z64_R13_AVX2.c
new file mode 100644
index 0000000000..b9c661f6ca
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z64_R13_AVX2.c
@@ -0,0 +1,749 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProcPc_BG1_Z64_R13_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes,  int8_t* llrRes ,  int8_t* llrProcBuf ) {
+   __m256i ymm0, ymm1, ymmRes0, ymmRes1;  
+        __m128i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m128i* p_llrProcBuf;
+        __m256i* p_llrProcBuf256; 
+        __m256i* p_llrRes; 
+// Process group with 1 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [0];
+    p_bnProcBufRes  = (__m256i*) &bnProcBufRes [0];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [0];
+    p_llrProcBuf256 = (__m256i*) &llrProcBuf   [0];
+    p_llrRes        = (__m256i*) &llrRes       [0];
+            for (int i=0,j=0;i<84;i++,j+=2) {
+             p_bnProcBufRes[i] = p_llrProcBuf256[i];
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j+1]);
+           ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j+1]);
+            ymmRes1 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [16128];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16128];
+    p_llrRes        = (__m256i*) &llrRes       [16128];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [17664];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16512];
+    p_llrRes        = (__m256i*) &llrRes       [16512];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [19584];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16896];
+    p_llrRes        = (__m256i*) &llrRes       [16896];
+        for (int i=0,j=0;i<4;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [24192];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [17664];
+    p_llrRes        = (__m256i*) &llrRes       [17664];
+        for (int i=0,j=0;i<8;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [34944];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [19200];
+    p_llrRes        = (__m256i*) &llrRes       [19200];
+        for (int i=0,j=0;i<6;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [44160];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [20352];
+    p_llrRes        = (__m256i*) &llrRes       [20352];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [47616];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [20736];
+    p_llrRes        = (__m256i*) &llrRes       [20736];
+        for (int i=0,j=0;i<8;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 11 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [62976];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [22272];
+    p_llrRes        = (__m256i*) &llrRes       [22272];
+            for (int i=0,j=0;i<6;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[720 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[720 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [75648];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [23424];
+    p_llrRes        = (__m256i*) &llrRes       [23424];
+            for (int i=0,j=0;i<8;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[960 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[960 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[1056 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[1056 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [94080];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [24960];
+    p_llrRes        = (__m256i*) &llrRes       [24960];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 14 CNs 
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+// Process group with <23 CNs 
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [99072];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [25344];
+    p_llrRes        = (__m256i*) &llrRes       [25344];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [109824];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [25728];
+    p_llrRes        = (__m256i*) &llrRes       [25728];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[696 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[696 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z6_R13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z6_R13_AVX2.c
new file mode 100644
index 0000000000..c223a8b5b1
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z6_R13_AVX2.c
@@ -0,0 +1,749 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProcPc_BG1_Z6_R13_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes,  int8_t* llrRes ,  int8_t* llrProcBuf ) {
+   __m256i ymm0, ymm1, ymmRes0, ymmRes1;  
+        __m128i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m128i* p_llrProcBuf;
+        __m256i* p_llrProcBuf256; 
+        __m256i* p_llrRes; 
+// Process group with 1 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [0];
+    p_bnProcBufRes  = (__m256i*) &bnProcBufRes [0];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [0];
+    p_llrProcBuf256 = (__m256i*) &llrProcBuf   [0];
+    p_llrRes        = (__m256i*) &llrRes       [0];
+            for (int i=0,j=0;i<8;i++,j+=2) {
+             p_bnProcBufRes[i] = p_llrProcBuf256[i];
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j+1]);
+           ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j+1]);
+            ymmRes1 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [16128];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16128];
+    p_llrRes        = (__m256i*) &llrRes       [16128];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [17664];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16512];
+    p_llrRes        = (__m256i*) &llrRes       [16512];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [19584];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16896];
+    p_llrRes        = (__m256i*) &llrRes       [16896];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [24192];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [17664];
+    p_llrRes        = (__m256i*) &llrRes       [17664];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [34944];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [19200];
+    p_llrRes        = (__m256i*) &llrRes       [19200];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [44160];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [20352];
+    p_llrRes        = (__m256i*) &llrRes       [20352];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [47616];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [20736];
+    p_llrRes        = (__m256i*) &llrRes       [20736];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 11 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [62976];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [22272];
+    p_llrRes        = (__m256i*) &llrRes       [22272];
+            for (int i=0,j=0;i<1;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[720 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[720 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [75648];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [23424];
+    p_llrRes        = (__m256i*) &llrRes       [23424];
+            for (int i=0,j=0;i<1;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[960 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[960 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[1056 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[1056 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [94080];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [24960];
+    p_llrRes        = (__m256i*) &llrRes       [24960];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 14 CNs 
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+// Process group with <23 CNs 
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [99072];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [25344];
+    p_llrRes        = (__m256i*) &llrRes       [25344];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [109824];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [25728];
+    p_llrRes        = (__m256i*) &llrRes       [25728];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[696 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[696 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z72_R13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z72_R13_AVX2.c
new file mode 100644
index 0000000000..0711e1b370
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z72_R13_AVX2.c
@@ -0,0 +1,749 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProcPc_BG1_Z72_R13_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes,  int8_t* llrRes ,  int8_t* llrProcBuf ) {
+   __m256i ymm0, ymm1, ymmRes0, ymmRes1;  
+        __m128i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m128i* p_llrProcBuf;
+        __m256i* p_llrProcBuf256; 
+        __m256i* p_llrRes; 
+// Process group with 1 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [0];
+    p_bnProcBufRes  = (__m256i*) &bnProcBufRes [0];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [0];
+    p_llrProcBuf256 = (__m256i*) &llrProcBuf   [0];
+    p_llrRes        = (__m256i*) &llrRes       [0];
+            for (int i=0,j=0;i<95;i++,j+=2) {
+             p_bnProcBufRes[i] = p_llrProcBuf256[i];
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j+1]);
+           ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j+1]);
+            ymmRes1 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [16128];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16128];
+    p_llrRes        = (__m256i*) &llrRes       [16128];
+        for (int i=0,j=0;i<3;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [17664];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16512];
+    p_llrRes        = (__m256i*) &llrRes       [16512];
+        for (int i=0,j=0;i<3;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [19584];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16896];
+    p_llrRes        = (__m256i*) &llrRes       [16896];
+        for (int i=0,j=0;i<5;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [24192];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [17664];
+    p_llrRes        = (__m256i*) &llrRes       [17664];
+        for (int i=0,j=0;i<9;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [34944];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [19200];
+    p_llrRes        = (__m256i*) &llrRes       [19200];
+        for (int i=0,j=0;i<7;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [44160];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [20352];
+    p_llrRes        = (__m256i*) &llrRes       [20352];
+        for (int i=0,j=0;i<3;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [47616];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [20736];
+    p_llrRes        = (__m256i*) &llrRes       [20736];
+        for (int i=0,j=0;i<9;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 11 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [62976];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [22272];
+    p_llrRes        = (__m256i*) &llrRes       [22272];
+            for (int i=0,j=0;i<7;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[720 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[720 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [75648];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [23424];
+    p_llrRes        = (__m256i*) &llrRes       [23424];
+            for (int i=0,j=0;i<9;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[960 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[960 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[1056 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[1056 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [94080];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [24960];
+    p_llrRes        = (__m256i*) &llrRes       [24960];
+        for (int i=0,j=0;i<3;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 14 CNs 
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+// Process group with <23 CNs 
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [99072];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [25344];
+    p_llrRes        = (__m256i*) &llrRes       [25344];
+        for (int i=0,j=0;i<3;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [109824];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [25728];
+    p_llrRes        = (__m256i*) &llrRes       [25728];
+        for (int i=0,j=0;i<3;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[696 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[696 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z7_R13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z7_R13_AVX2.c
new file mode 100644
index 0000000000..85384d8d39
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z7_R13_AVX2.c
@@ -0,0 +1,749 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProcPc_BG1_Z7_R13_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes,  int8_t* llrRes ,  int8_t* llrProcBuf ) {
+   __m256i ymm0, ymm1, ymmRes0, ymmRes1;  
+        __m128i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m128i* p_llrProcBuf;
+        __m256i* p_llrProcBuf256; 
+        __m256i* p_llrRes; 
+// Process group with 1 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [0];
+    p_bnProcBufRes  = (__m256i*) &bnProcBufRes [0];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [0];
+    p_llrProcBuf256 = (__m256i*) &llrProcBuf   [0];
+    p_llrRes        = (__m256i*) &llrRes       [0];
+            for (int i=0,j=0;i<10;i++,j+=2) {
+             p_bnProcBufRes[i] = p_llrProcBuf256[i];
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j+1]);
+           ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j+1]);
+            ymmRes1 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [16128];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16128];
+    p_llrRes        = (__m256i*) &llrRes       [16128];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [17664];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16512];
+    p_llrRes        = (__m256i*) &llrRes       [16512];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [19584];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16896];
+    p_llrRes        = (__m256i*) &llrRes       [16896];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [24192];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [17664];
+    p_llrRes        = (__m256i*) &llrRes       [17664];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [34944];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [19200];
+    p_llrRes        = (__m256i*) &llrRes       [19200];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [44160];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [20352];
+    p_llrRes        = (__m256i*) &llrRes       [20352];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [47616];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [20736];
+    p_llrRes        = (__m256i*) &llrRes       [20736];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 11 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [62976];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [22272];
+    p_llrRes        = (__m256i*) &llrRes       [22272];
+            for (int i=0,j=0;i<1;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[720 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[720 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [75648];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [23424];
+    p_llrRes        = (__m256i*) &llrRes       [23424];
+            for (int i=0,j=0;i<1;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[960 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[960 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[1056 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[1056 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [94080];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [24960];
+    p_llrRes        = (__m256i*) &llrRes       [24960];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 14 CNs 
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+// Process group with <23 CNs 
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [99072];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [25344];
+    p_llrRes        = (__m256i*) &llrRes       [25344];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [109824];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [25728];
+    p_llrRes        = (__m256i*) &llrRes       [25728];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[696 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[696 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z80_R13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z80_R13_AVX2.c
new file mode 100644
index 0000000000..e7e4c7b6f4
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z80_R13_AVX2.c
@@ -0,0 +1,749 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProcPc_BG1_Z80_R13_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes,  int8_t* llrRes ,  int8_t* llrProcBuf ) {
+   __m256i ymm0, ymm1, ymmRes0, ymmRes1;  
+        __m128i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m128i* p_llrProcBuf;
+        __m256i* p_llrProcBuf256; 
+        __m256i* p_llrRes; 
+// Process group with 1 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [0];
+    p_bnProcBufRes  = (__m256i*) &bnProcBufRes [0];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [0];
+    p_llrProcBuf256 = (__m256i*) &llrProcBuf   [0];
+    p_llrRes        = (__m256i*) &llrRes       [0];
+            for (int i=0,j=0;i<105;i++,j+=2) {
+             p_bnProcBufRes[i] = p_llrProcBuf256[i];
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j+1]);
+           ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j+1]);
+            ymmRes1 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [16128];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16128];
+    p_llrRes        = (__m256i*) &llrRes       [16128];
+        for (int i=0,j=0;i<3;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [17664];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16512];
+    p_llrRes        = (__m256i*) &llrRes       [16512];
+        for (int i=0,j=0;i<3;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [19584];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16896];
+    p_llrRes        = (__m256i*) &llrRes       [16896];
+        for (int i=0,j=0;i<5;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [24192];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [17664];
+    p_llrRes        = (__m256i*) &llrRes       [17664];
+        for (int i=0,j=0;i<10;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [34944];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [19200];
+    p_llrRes        = (__m256i*) &llrRes       [19200];
+        for (int i=0,j=0;i<8;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [44160];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [20352];
+    p_llrRes        = (__m256i*) &llrRes       [20352];
+        for (int i=0,j=0;i<3;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [47616];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [20736];
+    p_llrRes        = (__m256i*) &llrRes       [20736];
+        for (int i=0,j=0;i<10;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 11 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [62976];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [22272];
+    p_llrRes        = (__m256i*) &llrRes       [22272];
+            for (int i=0,j=0;i<8;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[720 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[720 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [75648];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [23424];
+    p_llrRes        = (__m256i*) &llrRes       [23424];
+            for (int i=0,j=0;i<10;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[960 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[960 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[1056 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[1056 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [94080];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [24960];
+    p_llrRes        = (__m256i*) &llrRes       [24960];
+        for (int i=0,j=0;i<3;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 14 CNs 
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+// Process group with <23 CNs 
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [99072];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [25344];
+    p_llrRes        = (__m256i*) &llrRes       [25344];
+        for (int i=0,j=0;i<3;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [109824];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [25728];
+    p_llrRes        = (__m256i*) &llrRes       [25728];
+        for (int i=0,j=0;i<3;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[696 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[696 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z88_R13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z88_R13_AVX2.c
new file mode 100644
index 0000000000..4d694f1874
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z88_R13_AVX2.c
@@ -0,0 +1,749 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProcPc_BG1_Z88_R13_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes,  int8_t* llrRes ,  int8_t* llrProcBuf ) {
+   __m256i ymm0, ymm1, ymmRes0, ymmRes1;  
+        __m128i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m128i* p_llrProcBuf;
+        __m256i* p_llrProcBuf256; 
+        __m256i* p_llrRes; 
+// Process group with 1 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [0];
+    p_bnProcBufRes  = (__m256i*) &bnProcBufRes [0];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [0];
+    p_llrProcBuf256 = (__m256i*) &llrProcBuf   [0];
+    p_llrRes        = (__m256i*) &llrRes       [0];
+            for (int i=0,j=0;i<116;i++,j+=2) {
+             p_bnProcBufRes[i] = p_llrProcBuf256[i];
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j+1]);
+           ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j+1]);
+            ymmRes1 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [16128];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16128];
+    p_llrRes        = (__m256i*) &llrRes       [16128];
+        for (int i=0,j=0;i<3;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [17664];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16512];
+    p_llrRes        = (__m256i*) &llrRes       [16512];
+        for (int i=0,j=0;i<3;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [19584];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16896];
+    p_llrRes        = (__m256i*) &llrRes       [16896];
+        for (int i=0,j=0;i<6;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [24192];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [17664];
+    p_llrRes        = (__m256i*) &llrRes       [17664];
+        for (int i=0,j=0;i<11;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [34944];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [19200];
+    p_llrRes        = (__m256i*) &llrRes       [19200];
+        for (int i=0,j=0;i<9;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [44160];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [20352];
+    p_llrRes        = (__m256i*) &llrRes       [20352];
+        for (int i=0,j=0;i<3;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [47616];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [20736];
+    p_llrRes        = (__m256i*) &llrRes       [20736];
+        for (int i=0,j=0;i<11;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 11 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [62976];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [22272];
+    p_llrRes        = (__m256i*) &llrRes       [22272];
+            for (int i=0,j=0;i<9;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[720 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[720 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [75648];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [23424];
+    p_llrRes        = (__m256i*) &llrRes       [23424];
+            for (int i=0,j=0;i<11;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[960 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[960 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[1056 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[1056 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [94080];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [24960];
+    p_llrRes        = (__m256i*) &llrRes       [24960];
+        for (int i=0,j=0;i<3;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 14 CNs 
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+// Process group with <23 CNs 
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [99072];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [25344];
+    p_llrRes        = (__m256i*) &llrRes       [25344];
+        for (int i=0,j=0;i<3;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [109824];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [25728];
+    p_llrRes        = (__m256i*) &llrRes       [25728];
+        for (int i=0,j=0;i<3;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[696 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[696 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z8_R13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z8_R13_AVX2.c
new file mode 100644
index 0000000000..548b9ab4aa
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z8_R13_AVX2.c
@@ -0,0 +1,749 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProcPc_BG1_Z8_R13_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes,  int8_t* llrRes ,  int8_t* llrProcBuf ) {
+   __m256i ymm0, ymm1, ymmRes0, ymmRes1;  
+        __m128i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m128i* p_llrProcBuf;
+        __m256i* p_llrProcBuf256; 
+        __m256i* p_llrRes; 
+// Process group with 1 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [0];
+    p_bnProcBufRes  = (__m256i*) &bnProcBufRes [0];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [0];
+    p_llrProcBuf256 = (__m256i*) &llrProcBuf   [0];
+    p_llrRes        = (__m256i*) &llrRes       [0];
+            for (int i=0,j=0;i<11;i++,j+=2) {
+             p_bnProcBufRes[i] = p_llrProcBuf256[i];
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j+1]);
+           ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j+1]);
+            ymmRes1 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [16128];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16128];
+    p_llrRes        = (__m256i*) &llrRes       [16128];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [17664];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16512];
+    p_llrRes        = (__m256i*) &llrRes       [16512];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [19584];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16896];
+    p_llrRes        = (__m256i*) &llrRes       [16896];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [24192];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [17664];
+    p_llrRes        = (__m256i*) &llrRes       [17664];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [34944];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [19200];
+    p_llrRes        = (__m256i*) &llrRes       [19200];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [44160];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [20352];
+    p_llrRes        = (__m256i*) &llrRes       [20352];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [47616];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [20736];
+    p_llrRes        = (__m256i*) &llrRes       [20736];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 11 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [62976];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [22272];
+    p_llrRes        = (__m256i*) &llrRes       [22272];
+            for (int i=0,j=0;i<1;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[720 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[720 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [75648];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [23424];
+    p_llrRes        = (__m256i*) &llrRes       [23424];
+            for (int i=0,j=0;i<1;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[960 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[960 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[1056 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[1056 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [94080];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [24960];
+    p_llrRes        = (__m256i*) &llrRes       [24960];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 14 CNs 
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+// Process group with <23 CNs 
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [99072];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [25344];
+    p_llrRes        = (__m256i*) &llrRes       [25344];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [109824];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [25728];
+    p_llrRes        = (__m256i*) &llrRes       [25728];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[696 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[696 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z96_R13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z96_R13_AVX2.c
new file mode 100644
index 0000000000..8db0776e95
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z96_R13_AVX2.c
@@ -0,0 +1,749 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProcPc_BG1_Z96_R13_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes,  int8_t* llrRes ,  int8_t* llrProcBuf ) {
+   __m256i ymm0, ymm1, ymmRes0, ymmRes1;  
+        __m128i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m128i* p_llrProcBuf;
+        __m256i* p_llrProcBuf256; 
+        __m256i* p_llrRes; 
+// Process group with 1 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [0];
+    p_bnProcBufRes  = (__m256i*) &bnProcBufRes [0];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [0];
+    p_llrProcBuf256 = (__m256i*) &llrProcBuf   [0];
+    p_llrRes        = (__m256i*) &llrRes       [0];
+            for (int i=0,j=0;i<126;i++,j+=2) {
+             p_bnProcBufRes[i] = p_llrProcBuf256[i];
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j+1]);
+           ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j+1]);
+            ymmRes1 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [16128];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16128];
+    p_llrRes        = (__m256i*) &llrRes       [16128];
+        for (int i=0,j=0;i<3;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [17664];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16512];
+    p_llrRes        = (__m256i*) &llrRes       [16512];
+        for (int i=0,j=0;i<3;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [19584];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16896];
+    p_llrRes        = (__m256i*) &llrRes       [16896];
+        for (int i=0,j=0;i<6;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [24192];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [17664];
+    p_llrRes        = (__m256i*) &llrRes       [17664];
+        for (int i=0,j=0;i<12;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [34944];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [19200];
+    p_llrRes        = (__m256i*) &llrRes       [19200];
+        for (int i=0,j=0;i<9;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [44160];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [20352];
+    p_llrRes        = (__m256i*) &llrRes       [20352];
+        for (int i=0,j=0;i<3;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [47616];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [20736];
+    p_llrRes        = (__m256i*) &llrRes       [20736];
+        for (int i=0,j=0;i<12;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 11 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [62976];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [22272];
+    p_llrRes        = (__m256i*) &llrRes       [22272];
+            for (int i=0,j=0;i<9;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[720 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[720 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [75648];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [23424];
+    p_llrRes        = (__m256i*) &llrRes       [23424];
+            for (int i=0,j=0;i<12;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[960 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[960 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[1056 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[1056 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [94080];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [24960];
+    p_llrRes        = (__m256i*) &llrRes       [24960];
+        for (int i=0,j=0;i<3;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 14 CNs 
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+// Process group with <23 CNs 
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [99072];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [25344];
+    p_llrRes        = (__m256i*) &llrRes       [25344];
+        for (int i=0,j=0;i<3;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [109824];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [25728];
+    p_llrRes        = (__m256i*) &llrRes       [25728];
+        for (int i=0,j=0;i<3;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[696 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[696 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z9_R13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z9_R13_AVX2.c
new file mode 100644
index 0000000000..44b8a15b39
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG1_Z9_R13_AVX2.c
@@ -0,0 +1,749 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProcPc_BG1_Z9_R13_AVX2(int8_t* bnProcBuf,int8_t* bnProcBufRes,  int8_t* llrRes ,  int8_t* llrProcBuf ) {
+   __m256i ymm0, ymm1, ymmRes0, ymmRes1;  
+        __m128i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m128i* p_llrProcBuf;
+        __m256i* p_llrProcBuf256; 
+        __m256i* p_llrRes; 
+// Process group with 1 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [0];
+    p_bnProcBufRes  = (__m256i*) &bnProcBufRes [0];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [0];
+    p_llrProcBuf256 = (__m256i*) &llrProcBuf   [0];
+    p_llrRes        = (__m256i*) &llrRes       [0];
+            for (int i=0,j=0;i<12;i++,j+=2) {
+             p_bnProcBufRes[i] = p_llrProcBuf256[i];
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j+1]);
+           ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j+1]);
+            ymmRes1 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [16128];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16128];
+    p_llrRes        = (__m256i*) &llrRes       [16128];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [17664];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16512];
+    p_llrRes        = (__m256i*) &llrRes       [16512];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [19584];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16896];
+    p_llrRes        = (__m256i*) &llrRes       [16896];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [24192];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [17664];
+    p_llrRes        = (__m256i*) &llrRes       [17664];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [34944];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [19200];
+    p_llrRes        = (__m256i*) &llrRes       [19200];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [44160];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [20352];
+    p_llrRes        = (__m256i*) &llrRes       [20352];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [47616];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [20736];
+    p_llrRes        = (__m256i*) &llrRes       [20736];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 11 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [62976];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [22272];
+    p_llrRes        = (__m256i*) &llrRes       [22272];
+            for (int i=0,j=0;i<1;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[720 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[720 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [75648];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [23424];
+    p_llrRes        = (__m256i*) &llrRes       [23424];
+            for (int i=0,j=0;i<2;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[768 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[864 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[960 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[960 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[1056 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[1056 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [94080];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [24960];
+    p_llrRes        = (__m256i*) &llrRes       [24960];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 14 CNs 
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+// Process group with <23 CNs 
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [99072];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [25344];
+    p_llrRes        = (__m256i*) &llrRes       [25344];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [109824];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [25728];
+    p_llrRes        = (__m256i*) &llrRes       [25728];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[552 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[576 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[600 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[624 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[648 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[672 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[696 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[696 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z104_R15_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z104_R15_AVX2.c
new file mode 100644
index 0000000000..f0ed3c3cd1
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z104_R15_AVX2.c
@@ -0,0 +1,757 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProcPc_BG2_Z104_R15_AVX2(int8_t* bnProcBuf, int8_t* bnProcBufRes,  int8_t* llrRes ,  int8_t* llrProcBuf ) {
+   __m256i ymm0, ymm1, ymmRes0, ymmRes1;  
+        __m128i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m128i* p_llrProcBuf;
+        __m256i* p_llrProcBuf256; 
+        __m256i* p_llrRes; 
+// Process group with 1 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [0];
+    p_bnProcBufRes  = (__m256i*) &bnProcBufRes [0];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [0];
+    p_llrProcBuf256 = (__m256i*) &llrProcBuf   [0];
+    p_llrRes        = (__m256i*) &llrRes       [0];
+            for (int i=0,j=0;i<124;i++,j+=2) {
+             p_bnProcBufRes[i] = p_llrProcBuf256[i];
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j+1]);
+           ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j+1]);
+            ymmRes1 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [14592];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [14592];
+    p_llrRes        = (__m256i*) &llrRes       [14592];
+        for (int i=0,j=0;i<7;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [18432];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [15360];
+    p_llrRes        = (__m256i*) &llrRes       [15360];
+        for (int i=0,j=0;i<4;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [20736];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [15744];
+    p_llrRes        = (__m256i*) &llrRes       [15744];
+        for (int i=0,j=0;i<4;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [23424];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16128];
+    p_llrRes        = (__m256i*) &llrRes       [16128];
+        for (int i=0,j=0;i<4;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [26496];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16512];
+    p_llrRes        = (__m256i*) &llrRes       [16512];
+        for (int i=0,j=0;i<7;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [33408];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [17280];
+    p_llrRes        = (__m256i*) &llrRes       [17280];
+        for (int i=0,j=0;i<4;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 11 CNs 
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [37248];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [17664];
+    p_llrRes        = (__m256i*) &llrRes       [17664];
+            for (int i=0,j=0;i<4;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [41856];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [18048];
+    p_llrRes        = (__m256i*) &llrRes       [18048];
+        for (int i=0,j=0;i<4;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 14 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [46848];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [18432];
+    p_llrRes        = (__m256i*) &llrRes       [18432];
+        for (int i=0,j=0;i<4;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [52224];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [18816];
+    p_llrRes        = (__m256i*) &llrRes       [18816];
+        for (int i=0,j=0;i<4;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [58368];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [19200];
+    p_llrRes        = (__m256i*) &llrRes       [19200];
+            for (int i=0,j=0;i<4;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with <23 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [66816];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [19584];
+    p_llrRes        = (__m256i*) &llrRes       [19584];
+        for (int i=0,j=0;i<4;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z10_R15_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z10_R15_AVX2.c
new file mode 100644
index 0000000000..06529a76d5
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z10_R15_AVX2.c
@@ -0,0 +1,757 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProcPc_BG2_Z10_R15_AVX2(int8_t* bnProcBuf, int8_t* bnProcBufRes,  int8_t* llrRes ,  int8_t* llrProcBuf ) {
+   __m256i ymm0, ymm1, ymmRes0, ymmRes1;  
+        __m128i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m128i* p_llrProcBuf;
+        __m256i* p_llrProcBuf256; 
+        __m256i* p_llrRes; 
+// Process group with 1 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [0];
+    p_bnProcBufRes  = (__m256i*) &bnProcBufRes [0];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [0];
+    p_llrProcBuf256 = (__m256i*) &llrProcBuf   [0];
+    p_llrRes        = (__m256i*) &llrRes       [0];
+            for (int i=0,j=0;i<12;i++,j+=2) {
+             p_bnProcBufRes[i] = p_llrProcBuf256[i];
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j+1]);
+           ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j+1]);
+            ymmRes1 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [14592];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [14592];
+    p_llrRes        = (__m256i*) &llrRes       [14592];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [18432];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [15360];
+    p_llrRes        = (__m256i*) &llrRes       [15360];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [20736];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [15744];
+    p_llrRes        = (__m256i*) &llrRes       [15744];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [23424];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16128];
+    p_llrRes        = (__m256i*) &llrRes       [16128];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [26496];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16512];
+    p_llrRes        = (__m256i*) &llrRes       [16512];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [33408];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [17280];
+    p_llrRes        = (__m256i*) &llrRes       [17280];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 11 CNs 
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [37248];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [17664];
+    p_llrRes        = (__m256i*) &llrRes       [17664];
+            for (int i=0,j=0;i<1;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [41856];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [18048];
+    p_llrRes        = (__m256i*) &llrRes       [18048];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 14 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [46848];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [18432];
+    p_llrRes        = (__m256i*) &llrRes       [18432];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [52224];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [18816];
+    p_llrRes        = (__m256i*) &llrRes       [18816];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [58368];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [19200];
+    p_llrRes        = (__m256i*) &llrRes       [19200];
+            for (int i=0,j=0;i<1;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with <23 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [66816];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [19584];
+    p_llrRes        = (__m256i*) &llrRes       [19584];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z112_R15_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z112_R15_AVX2.c
new file mode 100644
index 0000000000..d32d9f5a5a
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z112_R15_AVX2.c
@@ -0,0 +1,757 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProcPc_BG2_Z112_R15_AVX2(int8_t* bnProcBuf, int8_t* bnProcBufRes,  int8_t* llrRes ,  int8_t* llrProcBuf ) {
+   __m256i ymm0, ymm1, ymmRes0, ymmRes1;  
+        __m128i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m128i* p_llrProcBuf;
+        __m256i* p_llrProcBuf256; 
+        __m256i* p_llrRes; 
+// Process group with 1 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [0];
+    p_bnProcBufRes  = (__m256i*) &bnProcBufRes [0];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [0];
+    p_llrProcBuf256 = (__m256i*) &llrProcBuf   [0];
+    p_llrRes        = (__m256i*) &llrRes       [0];
+            for (int i=0,j=0;i<133;i++,j+=2) {
+             p_bnProcBufRes[i] = p_llrProcBuf256[i];
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j+1]);
+           ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j+1]);
+            ymmRes1 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [14592];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [14592];
+    p_llrRes        = (__m256i*) &llrRes       [14592];
+        for (int i=0,j=0;i<7;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [18432];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [15360];
+    p_llrRes        = (__m256i*) &llrRes       [15360];
+        for (int i=0,j=0;i<4;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [20736];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [15744];
+    p_llrRes        = (__m256i*) &llrRes       [15744];
+        for (int i=0,j=0;i<4;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [23424];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16128];
+    p_llrRes        = (__m256i*) &llrRes       [16128];
+        for (int i=0,j=0;i<4;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [26496];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16512];
+    p_llrRes        = (__m256i*) &llrRes       [16512];
+        for (int i=0,j=0;i<7;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [33408];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [17280];
+    p_llrRes        = (__m256i*) &llrRes       [17280];
+        for (int i=0,j=0;i<4;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 11 CNs 
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [37248];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [17664];
+    p_llrRes        = (__m256i*) &llrRes       [17664];
+            for (int i=0,j=0;i<4;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [41856];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [18048];
+    p_llrRes        = (__m256i*) &llrRes       [18048];
+        for (int i=0,j=0;i<4;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 14 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [46848];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [18432];
+    p_llrRes        = (__m256i*) &llrRes       [18432];
+        for (int i=0,j=0;i<4;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [52224];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [18816];
+    p_llrRes        = (__m256i*) &llrRes       [18816];
+        for (int i=0,j=0;i<4;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [58368];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [19200];
+    p_llrRes        = (__m256i*) &llrRes       [19200];
+            for (int i=0,j=0;i<4;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with <23 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [66816];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [19584];
+    p_llrRes        = (__m256i*) &llrRes       [19584];
+        for (int i=0,j=0;i<4;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z11_R15_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z11_R15_AVX2.c
new file mode 100644
index 0000000000..f4abd64e20
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z11_R15_AVX2.c
@@ -0,0 +1,757 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProcPc_BG2_Z11_R15_AVX2(int8_t* bnProcBuf, int8_t* bnProcBufRes,  int8_t* llrRes ,  int8_t* llrProcBuf ) {
+   __m256i ymm0, ymm1, ymmRes0, ymmRes1;  
+        __m128i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m128i* p_llrProcBuf;
+        __m256i* p_llrProcBuf256; 
+        __m256i* p_llrRes; 
+// Process group with 1 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [0];
+    p_bnProcBufRes  = (__m256i*) &bnProcBufRes [0];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [0];
+    p_llrProcBuf256 = (__m256i*) &llrProcBuf   [0];
+    p_llrRes        = (__m256i*) &llrRes       [0];
+            for (int i=0,j=0;i<14;i++,j+=2) {
+             p_bnProcBufRes[i] = p_llrProcBuf256[i];
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j+1]);
+           ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j+1]);
+            ymmRes1 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [14592];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [14592];
+    p_llrRes        = (__m256i*) &llrRes       [14592];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [18432];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [15360];
+    p_llrRes        = (__m256i*) &llrRes       [15360];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [20736];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [15744];
+    p_llrRes        = (__m256i*) &llrRes       [15744];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [23424];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16128];
+    p_llrRes        = (__m256i*) &llrRes       [16128];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [26496];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16512];
+    p_llrRes        = (__m256i*) &llrRes       [16512];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [33408];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [17280];
+    p_llrRes        = (__m256i*) &llrRes       [17280];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 11 CNs 
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [37248];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [17664];
+    p_llrRes        = (__m256i*) &llrRes       [17664];
+            for (int i=0,j=0;i<1;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [41856];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [18048];
+    p_llrRes        = (__m256i*) &llrRes       [18048];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 14 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [46848];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [18432];
+    p_llrRes        = (__m256i*) &llrRes       [18432];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [52224];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [18816];
+    p_llrRes        = (__m256i*) &llrRes       [18816];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [58368];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [19200];
+    p_llrRes        = (__m256i*) &llrRes       [19200];
+            for (int i=0,j=0;i<1;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with <23 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [66816];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [19584];
+    p_llrRes        = (__m256i*) &llrRes       [19584];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z120_R15_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z120_R15_AVX2.c
new file mode 100644
index 0000000000..192f387978
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z120_R15_AVX2.c
@@ -0,0 +1,757 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProcPc_BG2_Z120_R15_AVX2(int8_t* bnProcBuf, int8_t* bnProcBufRes,  int8_t* llrRes ,  int8_t* llrProcBuf ) {
+   __m256i ymm0, ymm1, ymmRes0, ymmRes1;  
+        __m128i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m128i* p_llrProcBuf;
+        __m256i* p_llrProcBuf256; 
+        __m256i* p_llrRes; 
+// Process group with 1 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [0];
+    p_bnProcBufRes  = (__m256i*) &bnProcBufRes [0];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [0];
+    p_llrProcBuf256 = (__m256i*) &llrProcBuf   [0];
+    p_llrRes        = (__m256i*) &llrRes       [0];
+            for (int i=0,j=0;i<143;i++,j+=2) {
+             p_bnProcBufRes[i] = p_llrProcBuf256[i];
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j+1]);
+           ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j+1]);
+            ymmRes1 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [14592];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [14592];
+    p_llrRes        = (__m256i*) &llrRes       [14592];
+        for (int i=0,j=0;i<8;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [18432];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [15360];
+    p_llrRes        = (__m256i*) &llrRes       [15360];
+        for (int i=0,j=0;i<4;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [20736];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [15744];
+    p_llrRes        = (__m256i*) &llrRes       [15744];
+        for (int i=0,j=0;i<4;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [23424];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16128];
+    p_llrRes        = (__m256i*) &llrRes       [16128];
+        for (int i=0,j=0;i<4;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [26496];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16512];
+    p_llrRes        = (__m256i*) &llrRes       [16512];
+        for (int i=0,j=0;i<8;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [33408];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [17280];
+    p_llrRes        = (__m256i*) &llrRes       [17280];
+        for (int i=0,j=0;i<4;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 11 CNs 
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [37248];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [17664];
+    p_llrRes        = (__m256i*) &llrRes       [17664];
+            for (int i=0,j=0;i<4;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [41856];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [18048];
+    p_llrRes        = (__m256i*) &llrRes       [18048];
+        for (int i=0,j=0;i<4;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 14 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [46848];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [18432];
+    p_llrRes        = (__m256i*) &llrRes       [18432];
+        for (int i=0,j=0;i<4;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [52224];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [18816];
+    p_llrRes        = (__m256i*) &llrRes       [18816];
+        for (int i=0,j=0;i<4;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [58368];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [19200];
+    p_llrRes        = (__m256i*) &llrRes       [19200];
+            for (int i=0,j=0;i<4;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with <23 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [66816];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [19584];
+    p_llrRes        = (__m256i*) &llrRes       [19584];
+        for (int i=0,j=0;i<4;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z128_R15_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z128_R15_AVX2.c
new file mode 100644
index 0000000000..7c87845b5b
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z128_R15_AVX2.c
@@ -0,0 +1,757 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProcPc_BG2_Z128_R15_AVX2(int8_t* bnProcBuf, int8_t* bnProcBufRes,  int8_t* llrRes ,  int8_t* llrProcBuf ) {
+   __m256i ymm0, ymm1, ymmRes0, ymmRes1;  
+        __m128i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m128i* p_llrProcBuf;
+        __m256i* p_llrProcBuf256; 
+        __m256i* p_llrRes; 
+// Process group with 1 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [0];
+    p_bnProcBufRes  = (__m256i*) &bnProcBufRes [0];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [0];
+    p_llrProcBuf256 = (__m256i*) &llrProcBuf   [0];
+    p_llrRes        = (__m256i*) &llrRes       [0];
+            for (int i=0,j=0;i<152;i++,j+=2) {
+             p_bnProcBufRes[i] = p_llrProcBuf256[i];
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j+1]);
+           ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j+1]);
+            ymmRes1 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [14592];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [14592];
+    p_llrRes        = (__m256i*) &llrRes       [14592];
+        for (int i=0,j=0;i<8;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [18432];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [15360];
+    p_llrRes        = (__m256i*) &llrRes       [15360];
+        for (int i=0,j=0;i<4;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [20736];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [15744];
+    p_llrRes        = (__m256i*) &llrRes       [15744];
+        for (int i=0,j=0;i<4;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [23424];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16128];
+    p_llrRes        = (__m256i*) &llrRes       [16128];
+        for (int i=0,j=0;i<4;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [26496];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16512];
+    p_llrRes        = (__m256i*) &llrRes       [16512];
+        for (int i=0,j=0;i<8;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [33408];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [17280];
+    p_llrRes        = (__m256i*) &llrRes       [17280];
+        for (int i=0,j=0;i<4;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 11 CNs 
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [37248];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [17664];
+    p_llrRes        = (__m256i*) &llrRes       [17664];
+            for (int i=0,j=0;i<4;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [41856];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [18048];
+    p_llrRes        = (__m256i*) &llrRes       [18048];
+        for (int i=0,j=0;i<4;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 14 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [46848];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [18432];
+    p_llrRes        = (__m256i*) &llrRes       [18432];
+        for (int i=0,j=0;i<4;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [52224];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [18816];
+    p_llrRes        = (__m256i*) &llrRes       [18816];
+        for (int i=0,j=0;i<4;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [58368];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [19200];
+    p_llrRes        = (__m256i*) &llrRes       [19200];
+            for (int i=0,j=0;i<4;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with <23 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [66816];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [19584];
+    p_llrRes        = (__m256i*) &llrRes       [19584];
+        for (int i=0,j=0;i<4;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z12_R15_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z12_R15_AVX2.c
new file mode 100644
index 0000000000..b640cc9b50
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z12_R15_AVX2.c
@@ -0,0 +1,757 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProcPc_BG2_Z12_R15_AVX2(int8_t* bnProcBuf, int8_t* bnProcBufRes,  int8_t* llrRes ,  int8_t* llrProcBuf ) {
+   __m256i ymm0, ymm1, ymmRes0, ymmRes1;  
+        __m128i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m128i* p_llrProcBuf;
+        __m256i* p_llrProcBuf256; 
+        __m256i* p_llrRes; 
+// Process group with 1 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [0];
+    p_bnProcBufRes  = (__m256i*) &bnProcBufRes [0];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [0];
+    p_llrProcBuf256 = (__m256i*) &llrProcBuf   [0];
+    p_llrRes        = (__m256i*) &llrRes       [0];
+            for (int i=0,j=0;i<15;i++,j+=2) {
+             p_bnProcBufRes[i] = p_llrProcBuf256[i];
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j+1]);
+           ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j+1]);
+            ymmRes1 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [14592];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [14592];
+    p_llrRes        = (__m256i*) &llrRes       [14592];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [18432];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [15360];
+    p_llrRes        = (__m256i*) &llrRes       [15360];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [20736];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [15744];
+    p_llrRes        = (__m256i*) &llrRes       [15744];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [23424];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16128];
+    p_llrRes        = (__m256i*) &llrRes       [16128];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [26496];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16512];
+    p_llrRes        = (__m256i*) &llrRes       [16512];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [33408];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [17280];
+    p_llrRes        = (__m256i*) &llrRes       [17280];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 11 CNs 
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [37248];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [17664];
+    p_llrRes        = (__m256i*) &llrRes       [17664];
+            for (int i=0,j=0;i<1;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [41856];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [18048];
+    p_llrRes        = (__m256i*) &llrRes       [18048];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 14 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [46848];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [18432];
+    p_llrRes        = (__m256i*) &llrRes       [18432];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [52224];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [18816];
+    p_llrRes        = (__m256i*) &llrRes       [18816];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [58368];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [19200];
+    p_llrRes        = (__m256i*) &llrRes       [19200];
+            for (int i=0,j=0;i<1;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with <23 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [66816];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [19584];
+    p_llrRes        = (__m256i*) &llrRes       [19584];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z13_R15_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z13_R15_AVX2.c
new file mode 100644
index 0000000000..fc400c6368
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z13_R15_AVX2.c
@@ -0,0 +1,757 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProcPc_BG2_Z13_R15_AVX2(int8_t* bnProcBuf, int8_t* bnProcBufRes,  int8_t* llrRes ,  int8_t* llrProcBuf ) {
+   __m256i ymm0, ymm1, ymmRes0, ymmRes1;  
+        __m128i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m128i* p_llrProcBuf;
+        __m256i* p_llrProcBuf256; 
+        __m256i* p_llrRes; 
+// Process group with 1 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [0];
+    p_bnProcBufRes  = (__m256i*) &bnProcBufRes [0];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [0];
+    p_llrProcBuf256 = (__m256i*) &llrProcBuf   [0];
+    p_llrRes        = (__m256i*) &llrRes       [0];
+            for (int i=0,j=0;i<16;i++,j+=2) {
+             p_bnProcBufRes[i] = p_llrProcBuf256[i];
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j+1]);
+           ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j+1]);
+            ymmRes1 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [14592];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [14592];
+    p_llrRes        = (__m256i*) &llrRes       [14592];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [18432];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [15360];
+    p_llrRes        = (__m256i*) &llrRes       [15360];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [20736];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [15744];
+    p_llrRes        = (__m256i*) &llrRes       [15744];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [23424];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16128];
+    p_llrRes        = (__m256i*) &llrRes       [16128];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [26496];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16512];
+    p_llrRes        = (__m256i*) &llrRes       [16512];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [33408];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [17280];
+    p_llrRes        = (__m256i*) &llrRes       [17280];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 11 CNs 
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [37248];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [17664];
+    p_llrRes        = (__m256i*) &llrRes       [17664];
+            for (int i=0,j=0;i<1;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [41856];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [18048];
+    p_llrRes        = (__m256i*) &llrRes       [18048];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 14 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [46848];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [18432];
+    p_llrRes        = (__m256i*) &llrRes       [18432];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [52224];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [18816];
+    p_llrRes        = (__m256i*) &llrRes       [18816];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [58368];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [19200];
+    p_llrRes        = (__m256i*) &llrRes       [19200];
+            for (int i=0,j=0;i<1;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with <23 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [66816];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [19584];
+    p_llrRes        = (__m256i*) &llrRes       [19584];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z144_R15_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z144_R15_AVX2.c
new file mode 100644
index 0000000000..8f10c6f9a6
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z144_R15_AVX2.c
@@ -0,0 +1,757 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProcPc_BG2_Z144_R15_AVX2(int8_t* bnProcBuf, int8_t* bnProcBufRes,  int8_t* llrRes ,  int8_t* llrProcBuf ) {
+   __m256i ymm0, ymm1, ymmRes0, ymmRes1;  
+        __m128i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m128i* p_llrProcBuf;
+        __m256i* p_llrProcBuf256; 
+        __m256i* p_llrRes; 
+// Process group with 1 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [0];
+    p_bnProcBufRes  = (__m256i*) &bnProcBufRes [0];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [0];
+    p_llrProcBuf256 = (__m256i*) &llrProcBuf   [0];
+    p_llrRes        = (__m256i*) &llrRes       [0];
+            for (int i=0,j=0;i<171;i++,j+=2) {
+             p_bnProcBufRes[i] = p_llrProcBuf256[i];
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j+1]);
+           ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j+1]);
+            ymmRes1 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [14592];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [14592];
+    p_llrRes        = (__m256i*) &llrRes       [14592];
+        for (int i=0,j=0;i<9;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [18432];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [15360];
+    p_llrRes        = (__m256i*) &llrRes       [15360];
+        for (int i=0,j=0;i<5;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [20736];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [15744];
+    p_llrRes        = (__m256i*) &llrRes       [15744];
+        for (int i=0,j=0;i<5;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [23424];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16128];
+    p_llrRes        = (__m256i*) &llrRes       [16128];
+        for (int i=0,j=0;i<5;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [26496];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16512];
+    p_llrRes        = (__m256i*) &llrRes       [16512];
+        for (int i=0,j=0;i<9;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [33408];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [17280];
+    p_llrRes        = (__m256i*) &llrRes       [17280];
+        for (int i=0,j=0;i<5;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 11 CNs 
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [37248];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [17664];
+    p_llrRes        = (__m256i*) &llrRes       [17664];
+            for (int i=0,j=0;i<5;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [41856];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [18048];
+    p_llrRes        = (__m256i*) &llrRes       [18048];
+        for (int i=0,j=0;i<5;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 14 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [46848];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [18432];
+    p_llrRes        = (__m256i*) &llrRes       [18432];
+        for (int i=0,j=0;i<5;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [52224];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [18816];
+    p_llrRes        = (__m256i*) &llrRes       [18816];
+        for (int i=0,j=0;i<5;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [58368];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [19200];
+    p_llrRes        = (__m256i*) &llrRes       [19200];
+            for (int i=0,j=0;i<5;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with <23 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [66816];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [19584];
+    p_llrRes        = (__m256i*) &llrRes       [19584];
+        for (int i=0,j=0;i<5;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z14_R15_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z14_R15_AVX2.c
new file mode 100644
index 0000000000..3f6be2d8b3
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z14_R15_AVX2.c
@@ -0,0 +1,757 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProcPc_BG2_Z14_R15_AVX2(int8_t* bnProcBuf, int8_t* bnProcBufRes,  int8_t* llrRes ,  int8_t* llrProcBuf ) {
+   __m256i ymm0, ymm1, ymmRes0, ymmRes1;  
+        __m128i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m128i* p_llrProcBuf;
+        __m256i* p_llrProcBuf256; 
+        __m256i* p_llrRes; 
+// Process group with 1 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [0];
+    p_bnProcBufRes  = (__m256i*) &bnProcBufRes [0];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [0];
+    p_llrProcBuf256 = (__m256i*) &llrProcBuf   [0];
+    p_llrRes        = (__m256i*) &llrRes       [0];
+            for (int i=0,j=0;i<17;i++,j+=2) {
+             p_bnProcBufRes[i] = p_llrProcBuf256[i];
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j+1]);
+           ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j+1]);
+            ymmRes1 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [14592];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [14592];
+    p_llrRes        = (__m256i*) &llrRes       [14592];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [18432];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [15360];
+    p_llrRes        = (__m256i*) &llrRes       [15360];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [20736];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [15744];
+    p_llrRes        = (__m256i*) &llrRes       [15744];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [23424];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16128];
+    p_llrRes        = (__m256i*) &llrRes       [16128];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [26496];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16512];
+    p_llrRes        = (__m256i*) &llrRes       [16512];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [33408];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [17280];
+    p_llrRes        = (__m256i*) &llrRes       [17280];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 11 CNs 
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [37248];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [17664];
+    p_llrRes        = (__m256i*) &llrRes       [17664];
+            for (int i=0,j=0;i<1;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [41856];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [18048];
+    p_llrRes        = (__m256i*) &llrRes       [18048];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 14 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [46848];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [18432];
+    p_llrRes        = (__m256i*) &llrRes       [18432];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [52224];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [18816];
+    p_llrRes        = (__m256i*) &llrRes       [18816];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [58368];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [19200];
+    p_llrRes        = (__m256i*) &llrRes       [19200];
+            for (int i=0,j=0;i<1;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with <23 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [66816];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [19584];
+    p_llrRes        = (__m256i*) &llrRes       [19584];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z15_R15_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z15_R15_AVX2.c
new file mode 100644
index 0000000000..18433a0bb9
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z15_R15_AVX2.c
@@ -0,0 +1,757 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProcPc_BG2_Z15_R15_AVX2(int8_t* bnProcBuf, int8_t* bnProcBufRes,  int8_t* llrRes ,  int8_t* llrProcBuf ) {
+   __m256i ymm0, ymm1, ymmRes0, ymmRes1;  
+        __m128i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m128i* p_llrProcBuf;
+        __m256i* p_llrProcBuf256; 
+        __m256i* p_llrRes; 
+// Process group with 1 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [0];
+    p_bnProcBufRes  = (__m256i*) &bnProcBufRes [0];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [0];
+    p_llrProcBuf256 = (__m256i*) &llrProcBuf   [0];
+    p_llrRes        = (__m256i*) &llrRes       [0];
+            for (int i=0,j=0;i<18;i++,j+=2) {
+             p_bnProcBufRes[i] = p_llrProcBuf256[i];
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j+1]);
+           ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j+1]);
+            ymmRes1 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [14592];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [14592];
+    p_llrRes        = (__m256i*) &llrRes       [14592];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [18432];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [15360];
+    p_llrRes        = (__m256i*) &llrRes       [15360];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [20736];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [15744];
+    p_llrRes        = (__m256i*) &llrRes       [15744];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [23424];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16128];
+    p_llrRes        = (__m256i*) &llrRes       [16128];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [26496];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16512];
+    p_llrRes        = (__m256i*) &llrRes       [16512];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [33408];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [17280];
+    p_llrRes        = (__m256i*) &llrRes       [17280];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 11 CNs 
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [37248];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [17664];
+    p_llrRes        = (__m256i*) &llrRes       [17664];
+            for (int i=0,j=0;i<1;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [41856];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [18048];
+    p_llrRes        = (__m256i*) &llrRes       [18048];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 14 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [46848];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [18432];
+    p_llrRes        = (__m256i*) &llrRes       [18432];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [52224];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [18816];
+    p_llrRes        = (__m256i*) &llrRes       [18816];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [58368];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [19200];
+    p_llrRes        = (__m256i*) &llrRes       [19200];
+            for (int i=0,j=0;i<1;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with <23 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [66816];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [19584];
+    p_llrRes        = (__m256i*) &llrRes       [19584];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z160_R15_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z160_R15_AVX2.c
new file mode 100644
index 0000000000..a707e979a3
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z160_R15_AVX2.c
@@ -0,0 +1,757 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProcPc_BG2_Z160_R15_AVX2(int8_t* bnProcBuf, int8_t* bnProcBufRes,  int8_t* llrRes ,  int8_t* llrProcBuf ) {
+   __m256i ymm0, ymm1, ymmRes0, ymmRes1;  
+        __m128i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m128i* p_llrProcBuf;
+        __m256i* p_llrProcBuf256; 
+        __m256i* p_llrRes; 
+// Process group with 1 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [0];
+    p_bnProcBufRes  = (__m256i*) &bnProcBufRes [0];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [0];
+    p_llrProcBuf256 = (__m256i*) &llrProcBuf   [0];
+    p_llrRes        = (__m256i*) &llrRes       [0];
+            for (int i=0,j=0;i<190;i++,j+=2) {
+             p_bnProcBufRes[i] = p_llrProcBuf256[i];
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j+1]);
+           ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j+1]);
+            ymmRes1 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [14592];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [14592];
+    p_llrRes        = (__m256i*) &llrRes       [14592];
+        for (int i=0,j=0;i<10;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [18432];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [15360];
+    p_llrRes        = (__m256i*) &llrRes       [15360];
+        for (int i=0,j=0;i<5;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [20736];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [15744];
+    p_llrRes        = (__m256i*) &llrRes       [15744];
+        for (int i=0,j=0;i<5;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [23424];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16128];
+    p_llrRes        = (__m256i*) &llrRes       [16128];
+        for (int i=0,j=0;i<5;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [26496];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16512];
+    p_llrRes        = (__m256i*) &llrRes       [16512];
+        for (int i=0,j=0;i<10;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [33408];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [17280];
+    p_llrRes        = (__m256i*) &llrRes       [17280];
+        for (int i=0,j=0;i<5;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 11 CNs 
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [37248];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [17664];
+    p_llrRes        = (__m256i*) &llrRes       [17664];
+            for (int i=0,j=0;i<5;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [41856];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [18048];
+    p_llrRes        = (__m256i*) &llrRes       [18048];
+        for (int i=0,j=0;i<5;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 14 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [46848];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [18432];
+    p_llrRes        = (__m256i*) &llrRes       [18432];
+        for (int i=0,j=0;i<5;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [52224];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [18816];
+    p_llrRes        = (__m256i*) &llrRes       [18816];
+        for (int i=0,j=0;i<5;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [58368];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [19200];
+    p_llrRes        = (__m256i*) &llrRes       [19200];
+            for (int i=0,j=0;i<5;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with <23 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [66816];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [19584];
+    p_llrRes        = (__m256i*) &llrRes       [19584];
+        for (int i=0,j=0;i<5;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z16_R15_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z16_R15_AVX2.c
new file mode 100644
index 0000000000..2db176ef99
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z16_R15_AVX2.c
@@ -0,0 +1,757 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProcPc_BG2_Z16_R15_AVX2(int8_t* bnProcBuf, int8_t* bnProcBufRes,  int8_t* llrRes ,  int8_t* llrProcBuf ) {
+   __m256i ymm0, ymm1, ymmRes0, ymmRes1;  
+        __m128i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m128i* p_llrProcBuf;
+        __m256i* p_llrProcBuf256; 
+        __m256i* p_llrRes; 
+// Process group with 1 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [0];
+    p_bnProcBufRes  = (__m256i*) &bnProcBufRes [0];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [0];
+    p_llrProcBuf256 = (__m256i*) &llrProcBuf   [0];
+    p_llrRes        = (__m256i*) &llrRes       [0];
+            for (int i=0,j=0;i<19;i++,j+=2) {
+             p_bnProcBufRes[i] = p_llrProcBuf256[i];
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j+1]);
+           ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j+1]);
+            ymmRes1 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [14592];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [14592];
+    p_llrRes        = (__m256i*) &llrRes       [14592];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [18432];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [15360];
+    p_llrRes        = (__m256i*) &llrRes       [15360];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [20736];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [15744];
+    p_llrRes        = (__m256i*) &llrRes       [15744];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [23424];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16128];
+    p_llrRes        = (__m256i*) &llrRes       [16128];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [26496];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16512];
+    p_llrRes        = (__m256i*) &llrRes       [16512];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [33408];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [17280];
+    p_llrRes        = (__m256i*) &llrRes       [17280];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 11 CNs 
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [37248];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [17664];
+    p_llrRes        = (__m256i*) &llrRes       [17664];
+            for (int i=0,j=0;i<1;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [41856];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [18048];
+    p_llrRes        = (__m256i*) &llrRes       [18048];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 14 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [46848];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [18432];
+    p_llrRes        = (__m256i*) &llrRes       [18432];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [52224];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [18816];
+    p_llrRes        = (__m256i*) &llrRes       [18816];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [58368];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [19200];
+    p_llrRes        = (__m256i*) &llrRes       [19200];
+            for (int i=0,j=0;i<1;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with <23 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [66816];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [19584];
+    p_llrRes        = (__m256i*) &llrRes       [19584];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z176_R15_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z176_R15_AVX2.c
new file mode 100644
index 0000000000..0a4986e855
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z176_R15_AVX2.c
@@ -0,0 +1,757 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProcPc_BG2_Z176_R15_AVX2(int8_t* bnProcBuf, int8_t* bnProcBufRes,  int8_t* llrRes ,  int8_t* llrProcBuf ) {
+   __m256i ymm0, ymm1, ymmRes0, ymmRes1;  
+        __m128i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m128i* p_llrProcBuf;
+        __m256i* p_llrProcBuf256; 
+        __m256i* p_llrRes; 
+// Process group with 1 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [0];
+    p_bnProcBufRes  = (__m256i*) &bnProcBufRes [0];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [0];
+    p_llrProcBuf256 = (__m256i*) &llrProcBuf   [0];
+    p_llrRes        = (__m256i*) &llrRes       [0];
+            for (int i=0,j=0;i<209;i++,j+=2) {
+             p_bnProcBufRes[i] = p_llrProcBuf256[i];
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j+1]);
+           ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j+1]);
+            ymmRes1 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [14592];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [14592];
+    p_llrRes        = (__m256i*) &llrRes       [14592];
+        for (int i=0,j=0;i<11;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [18432];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [15360];
+    p_llrRes        = (__m256i*) &llrRes       [15360];
+        for (int i=0,j=0;i<6;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [20736];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [15744];
+    p_llrRes        = (__m256i*) &llrRes       [15744];
+        for (int i=0,j=0;i<6;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [23424];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16128];
+    p_llrRes        = (__m256i*) &llrRes       [16128];
+        for (int i=0,j=0;i<6;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [26496];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16512];
+    p_llrRes        = (__m256i*) &llrRes       [16512];
+        for (int i=0,j=0;i<11;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [33408];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [17280];
+    p_llrRes        = (__m256i*) &llrRes       [17280];
+        for (int i=0,j=0;i<6;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 11 CNs 
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [37248];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [17664];
+    p_llrRes        = (__m256i*) &llrRes       [17664];
+            for (int i=0,j=0;i<6;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [41856];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [18048];
+    p_llrRes        = (__m256i*) &llrRes       [18048];
+        for (int i=0,j=0;i<6;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 14 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [46848];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [18432];
+    p_llrRes        = (__m256i*) &llrRes       [18432];
+        for (int i=0,j=0;i<6;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [52224];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [18816];
+    p_llrRes        = (__m256i*) &llrRes       [18816];
+        for (int i=0,j=0;i<6;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [58368];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [19200];
+    p_llrRes        = (__m256i*) &llrRes       [19200];
+            for (int i=0,j=0;i<6;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with <23 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [66816];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [19584];
+    p_llrRes        = (__m256i*) &llrRes       [19584];
+        for (int i=0,j=0;i<6;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z18_R15_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z18_R15_AVX2.c
new file mode 100644
index 0000000000..73ec5b7694
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z18_R15_AVX2.c
@@ -0,0 +1,757 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProcPc_BG2_Z18_R15_AVX2(int8_t* bnProcBuf, int8_t* bnProcBufRes,  int8_t* llrRes ,  int8_t* llrProcBuf ) {
+   __m256i ymm0, ymm1, ymmRes0, ymmRes1;  
+        __m128i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m128i* p_llrProcBuf;
+        __m256i* p_llrProcBuf256; 
+        __m256i* p_llrRes; 
+// Process group with 1 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [0];
+    p_bnProcBufRes  = (__m256i*) &bnProcBufRes [0];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [0];
+    p_llrProcBuf256 = (__m256i*) &llrProcBuf   [0];
+    p_llrRes        = (__m256i*) &llrRes       [0];
+            for (int i=0,j=0;i<22;i++,j+=2) {
+             p_bnProcBufRes[i] = p_llrProcBuf256[i];
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j+1]);
+           ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j+1]);
+            ymmRes1 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [14592];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [14592];
+    p_llrRes        = (__m256i*) &llrRes       [14592];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [18432];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [15360];
+    p_llrRes        = (__m256i*) &llrRes       [15360];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [20736];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [15744];
+    p_llrRes        = (__m256i*) &llrRes       [15744];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [23424];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16128];
+    p_llrRes        = (__m256i*) &llrRes       [16128];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [26496];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16512];
+    p_llrRes        = (__m256i*) &llrRes       [16512];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [33408];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [17280];
+    p_llrRes        = (__m256i*) &llrRes       [17280];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 11 CNs 
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [37248];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [17664];
+    p_llrRes        = (__m256i*) &llrRes       [17664];
+            for (int i=0,j=0;i<1;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [41856];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [18048];
+    p_llrRes        = (__m256i*) &llrRes       [18048];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 14 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [46848];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [18432];
+    p_llrRes        = (__m256i*) &llrRes       [18432];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [52224];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [18816];
+    p_llrRes        = (__m256i*) &llrRes       [18816];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [58368];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [19200];
+    p_llrRes        = (__m256i*) &llrRes       [19200];
+            for (int i=0,j=0;i<1;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with <23 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [66816];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [19584];
+    p_llrRes        = (__m256i*) &llrRes       [19584];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z192_R15_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z192_R15_AVX2.c
new file mode 100644
index 0000000000..57c3a14331
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z192_R15_AVX2.c
@@ -0,0 +1,757 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProcPc_BG2_Z192_R15_AVX2(int8_t* bnProcBuf, int8_t* bnProcBufRes,  int8_t* llrRes ,  int8_t* llrProcBuf ) {
+   __m256i ymm0, ymm1, ymmRes0, ymmRes1;  
+        __m128i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m128i* p_llrProcBuf;
+        __m256i* p_llrProcBuf256; 
+        __m256i* p_llrRes; 
+// Process group with 1 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [0];
+    p_bnProcBufRes  = (__m256i*) &bnProcBufRes [0];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [0];
+    p_llrProcBuf256 = (__m256i*) &llrProcBuf   [0];
+    p_llrRes        = (__m256i*) &llrRes       [0];
+            for (int i=0,j=0;i<228;i++,j+=2) {
+             p_bnProcBufRes[i] = p_llrProcBuf256[i];
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j+1]);
+           ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j+1]);
+            ymmRes1 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [14592];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [14592];
+    p_llrRes        = (__m256i*) &llrRes       [14592];
+        for (int i=0,j=0;i<12;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [18432];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [15360];
+    p_llrRes        = (__m256i*) &llrRes       [15360];
+        for (int i=0,j=0;i<6;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [20736];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [15744];
+    p_llrRes        = (__m256i*) &llrRes       [15744];
+        for (int i=0,j=0;i<6;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [23424];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16128];
+    p_llrRes        = (__m256i*) &llrRes       [16128];
+        for (int i=0,j=0;i<6;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [26496];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16512];
+    p_llrRes        = (__m256i*) &llrRes       [16512];
+        for (int i=0,j=0;i<12;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [33408];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [17280];
+    p_llrRes        = (__m256i*) &llrRes       [17280];
+        for (int i=0,j=0;i<6;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 11 CNs 
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [37248];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [17664];
+    p_llrRes        = (__m256i*) &llrRes       [17664];
+            for (int i=0,j=0;i<6;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [41856];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [18048];
+    p_llrRes        = (__m256i*) &llrRes       [18048];
+        for (int i=0,j=0;i<6;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 14 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [46848];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [18432];
+    p_llrRes        = (__m256i*) &llrRes       [18432];
+        for (int i=0,j=0;i<6;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [52224];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [18816];
+    p_llrRes        = (__m256i*) &llrRes       [18816];
+        for (int i=0,j=0;i<6;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [58368];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [19200];
+    p_llrRes        = (__m256i*) &llrRes       [19200];
+            for (int i=0,j=0;i<6;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with <23 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [66816];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [19584];
+    p_llrRes        = (__m256i*) &llrRes       [19584];
+        for (int i=0,j=0;i<6;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z208_R15_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z208_R15_AVX2.c
new file mode 100644
index 0000000000..df3810a159
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z208_R15_AVX2.c
@@ -0,0 +1,757 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProcPc_BG2_Z208_R15_AVX2(int8_t* bnProcBuf, int8_t* bnProcBufRes,  int8_t* llrRes ,  int8_t* llrProcBuf ) {
+   __m256i ymm0, ymm1, ymmRes0, ymmRes1;  
+        __m128i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m128i* p_llrProcBuf;
+        __m256i* p_llrProcBuf256; 
+        __m256i* p_llrRes; 
+// Process group with 1 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [0];
+    p_bnProcBufRes  = (__m256i*) &bnProcBufRes [0];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [0];
+    p_llrProcBuf256 = (__m256i*) &llrProcBuf   [0];
+    p_llrRes        = (__m256i*) &llrRes       [0];
+            for (int i=0,j=0;i<247;i++,j+=2) {
+             p_bnProcBufRes[i] = p_llrProcBuf256[i];
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j+1]);
+           ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j+1]);
+            ymmRes1 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [14592];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [14592];
+    p_llrRes        = (__m256i*) &llrRes       [14592];
+        for (int i=0,j=0;i<13;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [18432];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [15360];
+    p_llrRes        = (__m256i*) &llrRes       [15360];
+        for (int i=0,j=0;i<7;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [20736];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [15744];
+    p_llrRes        = (__m256i*) &llrRes       [15744];
+        for (int i=0,j=0;i<7;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [23424];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16128];
+    p_llrRes        = (__m256i*) &llrRes       [16128];
+        for (int i=0,j=0;i<7;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [26496];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16512];
+    p_llrRes        = (__m256i*) &llrRes       [16512];
+        for (int i=0,j=0;i<13;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [33408];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [17280];
+    p_llrRes        = (__m256i*) &llrRes       [17280];
+        for (int i=0,j=0;i<7;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 11 CNs 
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [37248];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [17664];
+    p_llrRes        = (__m256i*) &llrRes       [17664];
+            for (int i=0,j=0;i<7;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [41856];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [18048];
+    p_llrRes        = (__m256i*) &llrRes       [18048];
+        for (int i=0,j=0;i<7;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 14 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [46848];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [18432];
+    p_llrRes        = (__m256i*) &llrRes       [18432];
+        for (int i=0,j=0;i<7;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [52224];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [18816];
+    p_llrRes        = (__m256i*) &llrRes       [18816];
+        for (int i=0,j=0;i<7;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [58368];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [19200];
+    p_llrRes        = (__m256i*) &llrRes       [19200];
+            for (int i=0,j=0;i<7;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with <23 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [66816];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [19584];
+    p_llrRes        = (__m256i*) &llrRes       [19584];
+        for (int i=0,j=0;i<7;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z20_R15_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z20_R15_AVX2.c
new file mode 100644
index 0000000000..ccabb48171
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z20_R15_AVX2.c
@@ -0,0 +1,757 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProcPc_BG2_Z20_R15_AVX2(int8_t* bnProcBuf, int8_t* bnProcBufRes,  int8_t* llrRes ,  int8_t* llrProcBuf ) {
+   __m256i ymm0, ymm1, ymmRes0, ymmRes1;  
+        __m128i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m128i* p_llrProcBuf;
+        __m256i* p_llrProcBuf256; 
+        __m256i* p_llrRes; 
+// Process group with 1 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [0];
+    p_bnProcBufRes  = (__m256i*) &bnProcBufRes [0];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [0];
+    p_llrProcBuf256 = (__m256i*) &llrProcBuf   [0];
+    p_llrRes        = (__m256i*) &llrRes       [0];
+            for (int i=0,j=0;i<24;i++,j+=2) {
+             p_bnProcBufRes[i] = p_llrProcBuf256[i];
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j+1]);
+           ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j+1]);
+            ymmRes1 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [14592];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [14592];
+    p_llrRes        = (__m256i*) &llrRes       [14592];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [18432];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [15360];
+    p_llrRes        = (__m256i*) &llrRes       [15360];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [20736];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [15744];
+    p_llrRes        = (__m256i*) &llrRes       [15744];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [23424];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16128];
+    p_llrRes        = (__m256i*) &llrRes       [16128];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [26496];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16512];
+    p_llrRes        = (__m256i*) &llrRes       [16512];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [33408];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [17280];
+    p_llrRes        = (__m256i*) &llrRes       [17280];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 11 CNs 
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [37248];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [17664];
+    p_llrRes        = (__m256i*) &llrRes       [17664];
+            for (int i=0,j=0;i<1;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [41856];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [18048];
+    p_llrRes        = (__m256i*) &llrRes       [18048];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 14 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [46848];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [18432];
+    p_llrRes        = (__m256i*) &llrRes       [18432];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [52224];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [18816];
+    p_llrRes        = (__m256i*) &llrRes       [18816];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [58368];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [19200];
+    p_llrRes        = (__m256i*) &llrRes       [19200];
+            for (int i=0,j=0;i<1;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with <23 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [66816];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [19584];
+    p_llrRes        = (__m256i*) &llrRes       [19584];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z224_R15_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z224_R15_AVX2.c
new file mode 100644
index 0000000000..3863cc0b78
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z224_R15_AVX2.c
@@ -0,0 +1,757 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProcPc_BG2_Z224_R15_AVX2(int8_t* bnProcBuf, int8_t* bnProcBufRes,  int8_t* llrRes ,  int8_t* llrProcBuf ) {
+   __m256i ymm0, ymm1, ymmRes0, ymmRes1;  
+        __m128i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m128i* p_llrProcBuf;
+        __m256i* p_llrProcBuf256; 
+        __m256i* p_llrRes; 
+// Process group with 1 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [0];
+    p_bnProcBufRes  = (__m256i*) &bnProcBufRes [0];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [0];
+    p_llrProcBuf256 = (__m256i*) &llrProcBuf   [0];
+    p_llrRes        = (__m256i*) &llrRes       [0];
+            for (int i=0,j=0;i<266;i++,j+=2) {
+             p_bnProcBufRes[i] = p_llrProcBuf256[i];
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j+1]);
+           ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j+1]);
+            ymmRes1 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [14592];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [14592];
+    p_llrRes        = (__m256i*) &llrRes       [14592];
+        for (int i=0,j=0;i<14;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [18432];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [15360];
+    p_llrRes        = (__m256i*) &llrRes       [15360];
+        for (int i=0,j=0;i<7;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [20736];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [15744];
+    p_llrRes        = (__m256i*) &llrRes       [15744];
+        for (int i=0,j=0;i<7;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [23424];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16128];
+    p_llrRes        = (__m256i*) &llrRes       [16128];
+        for (int i=0,j=0;i<7;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [26496];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16512];
+    p_llrRes        = (__m256i*) &llrRes       [16512];
+        for (int i=0,j=0;i<14;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [33408];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [17280];
+    p_llrRes        = (__m256i*) &llrRes       [17280];
+        for (int i=0,j=0;i<7;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 11 CNs 
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [37248];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [17664];
+    p_llrRes        = (__m256i*) &llrRes       [17664];
+            for (int i=0,j=0;i<7;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [41856];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [18048];
+    p_llrRes        = (__m256i*) &llrRes       [18048];
+        for (int i=0,j=0;i<7;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 14 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [46848];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [18432];
+    p_llrRes        = (__m256i*) &llrRes       [18432];
+        for (int i=0,j=0;i<7;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [52224];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [18816];
+    p_llrRes        = (__m256i*) &llrRes       [18816];
+        for (int i=0,j=0;i<7;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [58368];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [19200];
+    p_llrRes        = (__m256i*) &llrRes       [19200];
+            for (int i=0,j=0;i<7;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with <23 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [66816];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [19584];
+    p_llrRes        = (__m256i*) &llrRes       [19584];
+        for (int i=0,j=0;i<7;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z22_R15_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z22_R15_AVX2.c
new file mode 100644
index 0000000000..e63c5fd552
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z22_R15_AVX2.c
@@ -0,0 +1,757 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProcPc_BG2_Z22_R15_AVX2(int8_t* bnProcBuf, int8_t* bnProcBufRes,  int8_t* llrRes ,  int8_t* llrProcBuf ) {
+   __m256i ymm0, ymm1, ymmRes0, ymmRes1;  
+        __m128i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m128i* p_llrProcBuf;
+        __m256i* p_llrProcBuf256; 
+        __m256i* p_llrRes; 
+// Process group with 1 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [0];
+    p_bnProcBufRes  = (__m256i*) &bnProcBufRes [0];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [0];
+    p_llrProcBuf256 = (__m256i*) &llrProcBuf   [0];
+    p_llrRes        = (__m256i*) &llrRes       [0];
+            for (int i=0,j=0;i<27;i++,j+=2) {
+             p_bnProcBufRes[i] = p_llrProcBuf256[i];
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j+1]);
+           ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j+1]);
+            ymmRes1 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [14592];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [14592];
+    p_llrRes        = (__m256i*) &llrRes       [14592];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [18432];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [15360];
+    p_llrRes        = (__m256i*) &llrRes       [15360];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [20736];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [15744];
+    p_llrRes        = (__m256i*) &llrRes       [15744];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [23424];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16128];
+    p_llrRes        = (__m256i*) &llrRes       [16128];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [26496];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16512];
+    p_llrRes        = (__m256i*) &llrRes       [16512];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [33408];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [17280];
+    p_llrRes        = (__m256i*) &llrRes       [17280];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 11 CNs 
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [37248];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [17664];
+    p_llrRes        = (__m256i*) &llrRes       [17664];
+            for (int i=0,j=0;i<1;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [41856];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [18048];
+    p_llrRes        = (__m256i*) &llrRes       [18048];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 14 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [46848];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [18432];
+    p_llrRes        = (__m256i*) &llrRes       [18432];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [52224];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [18816];
+    p_llrRes        = (__m256i*) &llrRes       [18816];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [58368];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [19200];
+    p_llrRes        = (__m256i*) &llrRes       [19200];
+            for (int i=0,j=0;i<1;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with <23 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [66816];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [19584];
+    p_llrRes        = (__m256i*) &llrRes       [19584];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z240_R15_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z240_R15_AVX2.c
new file mode 100644
index 0000000000..6502335168
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z240_R15_AVX2.c
@@ -0,0 +1,757 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProcPc_BG2_Z240_R15_AVX2(int8_t* bnProcBuf, int8_t* bnProcBufRes,  int8_t* llrRes ,  int8_t* llrProcBuf ) {
+   __m256i ymm0, ymm1, ymmRes0, ymmRes1;  
+        __m128i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m128i* p_llrProcBuf;
+        __m256i* p_llrProcBuf256; 
+        __m256i* p_llrRes; 
+// Process group with 1 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [0];
+    p_bnProcBufRes  = (__m256i*) &bnProcBufRes [0];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [0];
+    p_llrProcBuf256 = (__m256i*) &llrProcBuf   [0];
+    p_llrRes        = (__m256i*) &llrRes       [0];
+            for (int i=0,j=0;i<285;i++,j+=2) {
+             p_bnProcBufRes[i] = p_llrProcBuf256[i];
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j+1]);
+           ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j+1]);
+            ymmRes1 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [14592];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [14592];
+    p_llrRes        = (__m256i*) &llrRes       [14592];
+        for (int i=0,j=0;i<15;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [18432];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [15360];
+    p_llrRes        = (__m256i*) &llrRes       [15360];
+        for (int i=0,j=0;i<8;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [20736];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [15744];
+    p_llrRes        = (__m256i*) &llrRes       [15744];
+        for (int i=0,j=0;i<8;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [23424];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16128];
+    p_llrRes        = (__m256i*) &llrRes       [16128];
+        for (int i=0,j=0;i<8;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [26496];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16512];
+    p_llrRes        = (__m256i*) &llrRes       [16512];
+        for (int i=0,j=0;i<15;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [33408];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [17280];
+    p_llrRes        = (__m256i*) &llrRes       [17280];
+        for (int i=0,j=0;i<8;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 11 CNs 
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [37248];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [17664];
+    p_llrRes        = (__m256i*) &llrRes       [17664];
+            for (int i=0,j=0;i<8;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [41856];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [18048];
+    p_llrRes        = (__m256i*) &llrRes       [18048];
+        for (int i=0,j=0;i<8;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 14 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [46848];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [18432];
+    p_llrRes        = (__m256i*) &llrRes       [18432];
+        for (int i=0,j=0;i<8;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [52224];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [18816];
+    p_llrRes        = (__m256i*) &llrRes       [18816];
+        for (int i=0,j=0;i<8;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [58368];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [19200];
+    p_llrRes        = (__m256i*) &llrRes       [19200];
+            for (int i=0,j=0;i<8;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with <23 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [66816];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [19584];
+    p_llrRes        = (__m256i*) &llrRes       [19584];
+        for (int i=0,j=0;i<8;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z24_R15_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z24_R15_AVX2.c
new file mode 100644
index 0000000000..bf727cb7da
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z24_R15_AVX2.c
@@ -0,0 +1,757 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProcPc_BG2_Z24_R15_AVX2(int8_t* bnProcBuf, int8_t* bnProcBufRes,  int8_t* llrRes ,  int8_t* llrProcBuf ) {
+   __m256i ymm0, ymm1, ymmRes0, ymmRes1;  
+        __m128i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m128i* p_llrProcBuf;
+        __m256i* p_llrProcBuf256; 
+        __m256i* p_llrRes; 
+// Process group with 1 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [0];
+    p_bnProcBufRes  = (__m256i*) &bnProcBufRes [0];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [0];
+    p_llrProcBuf256 = (__m256i*) &llrProcBuf   [0];
+    p_llrRes        = (__m256i*) &llrRes       [0];
+            for (int i=0,j=0;i<29;i++,j+=2) {
+             p_bnProcBufRes[i] = p_llrProcBuf256[i];
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j+1]);
+           ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j+1]);
+            ymmRes1 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [14592];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [14592];
+    p_llrRes        = (__m256i*) &llrRes       [14592];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [18432];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [15360];
+    p_llrRes        = (__m256i*) &llrRes       [15360];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [20736];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [15744];
+    p_llrRes        = (__m256i*) &llrRes       [15744];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [23424];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16128];
+    p_llrRes        = (__m256i*) &llrRes       [16128];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [26496];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16512];
+    p_llrRes        = (__m256i*) &llrRes       [16512];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [33408];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [17280];
+    p_llrRes        = (__m256i*) &llrRes       [17280];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 11 CNs 
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [37248];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [17664];
+    p_llrRes        = (__m256i*) &llrRes       [17664];
+            for (int i=0,j=0;i<1;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [41856];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [18048];
+    p_llrRes        = (__m256i*) &llrRes       [18048];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 14 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [46848];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [18432];
+    p_llrRes        = (__m256i*) &llrRes       [18432];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [52224];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [18816];
+    p_llrRes        = (__m256i*) &llrRes       [18816];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [58368];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [19200];
+    p_llrRes        = (__m256i*) &llrRes       [19200];
+            for (int i=0,j=0;i<1;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with <23 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [66816];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [19584];
+    p_llrRes        = (__m256i*) &llrRes       [19584];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z256_R15_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z256_R15_AVX2.c
new file mode 100644
index 0000000000..21e3b405ee
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z256_R15_AVX2.c
@@ -0,0 +1,757 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProcPc_BG2_Z256_R15_AVX2(int8_t* bnProcBuf, int8_t* bnProcBufRes,  int8_t* llrRes ,  int8_t* llrProcBuf ) {
+   __m256i ymm0, ymm1, ymmRes0, ymmRes1;  
+        __m128i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m128i* p_llrProcBuf;
+        __m256i* p_llrProcBuf256; 
+        __m256i* p_llrRes; 
+// Process group with 1 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [0];
+    p_bnProcBufRes  = (__m256i*) &bnProcBufRes [0];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [0];
+    p_llrProcBuf256 = (__m256i*) &llrProcBuf   [0];
+    p_llrRes        = (__m256i*) &llrRes       [0];
+            for (int i=0,j=0;i<304;i++,j+=2) {
+             p_bnProcBufRes[i] = p_llrProcBuf256[i];
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j+1]);
+           ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j+1]);
+            ymmRes1 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [14592];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [14592];
+    p_llrRes        = (__m256i*) &llrRes       [14592];
+        for (int i=0,j=0;i<16;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [18432];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [15360];
+    p_llrRes        = (__m256i*) &llrRes       [15360];
+        for (int i=0,j=0;i<8;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [20736];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [15744];
+    p_llrRes        = (__m256i*) &llrRes       [15744];
+        for (int i=0,j=0;i<8;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [23424];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16128];
+    p_llrRes        = (__m256i*) &llrRes       [16128];
+        for (int i=0,j=0;i<8;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [26496];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16512];
+    p_llrRes        = (__m256i*) &llrRes       [16512];
+        for (int i=0,j=0;i<16;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [33408];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [17280];
+    p_llrRes        = (__m256i*) &llrRes       [17280];
+        for (int i=0,j=0;i<8;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 11 CNs 
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [37248];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [17664];
+    p_llrRes        = (__m256i*) &llrRes       [17664];
+            for (int i=0,j=0;i<8;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [41856];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [18048];
+    p_llrRes        = (__m256i*) &llrRes       [18048];
+        for (int i=0,j=0;i<8;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 14 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [46848];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [18432];
+    p_llrRes        = (__m256i*) &llrRes       [18432];
+        for (int i=0,j=0;i<8;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [52224];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [18816];
+    p_llrRes        = (__m256i*) &llrRes       [18816];
+        for (int i=0,j=0;i<8;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [58368];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [19200];
+    p_llrRes        = (__m256i*) &llrRes       [19200];
+            for (int i=0,j=0;i<8;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with <23 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [66816];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [19584];
+    p_llrRes        = (__m256i*) &llrRes       [19584];
+        for (int i=0,j=0;i<8;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z26_R15_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z26_R15_AVX2.c
new file mode 100644
index 0000000000..aada1582fb
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z26_R15_AVX2.c
@@ -0,0 +1,757 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProcPc_BG2_Z26_R15_AVX2(int8_t* bnProcBuf, int8_t* bnProcBufRes,  int8_t* llrRes ,  int8_t* llrProcBuf ) {
+   __m256i ymm0, ymm1, ymmRes0, ymmRes1;  
+        __m128i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m128i* p_llrProcBuf;
+        __m256i* p_llrProcBuf256; 
+        __m256i* p_llrRes; 
+// Process group with 1 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [0];
+    p_bnProcBufRes  = (__m256i*) &bnProcBufRes [0];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [0];
+    p_llrProcBuf256 = (__m256i*) &llrProcBuf   [0];
+    p_llrRes        = (__m256i*) &llrRes       [0];
+            for (int i=0,j=0;i<31;i++,j+=2) {
+             p_bnProcBufRes[i] = p_llrProcBuf256[i];
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j+1]);
+           ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j+1]);
+            ymmRes1 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [14592];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [14592];
+    p_llrRes        = (__m256i*) &llrRes       [14592];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [18432];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [15360];
+    p_llrRes        = (__m256i*) &llrRes       [15360];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [20736];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [15744];
+    p_llrRes        = (__m256i*) &llrRes       [15744];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [23424];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16128];
+    p_llrRes        = (__m256i*) &llrRes       [16128];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [26496];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16512];
+    p_llrRes        = (__m256i*) &llrRes       [16512];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [33408];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [17280];
+    p_llrRes        = (__m256i*) &llrRes       [17280];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 11 CNs 
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [37248];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [17664];
+    p_llrRes        = (__m256i*) &llrRes       [17664];
+            for (int i=0,j=0;i<1;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [41856];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [18048];
+    p_llrRes        = (__m256i*) &llrRes       [18048];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 14 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [46848];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [18432];
+    p_llrRes        = (__m256i*) &llrRes       [18432];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [52224];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [18816];
+    p_llrRes        = (__m256i*) &llrRes       [18816];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [58368];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [19200];
+    p_llrRes        = (__m256i*) &llrRes       [19200];
+            for (int i=0,j=0;i<1;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with <23 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [66816];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [19584];
+    p_llrRes        = (__m256i*) &llrRes       [19584];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z288_R15_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z288_R15_AVX2.c
new file mode 100644
index 0000000000..dbd644f48b
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z288_R15_AVX2.c
@@ -0,0 +1,757 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProcPc_BG2_Z288_R15_AVX2(int8_t* bnProcBuf, int8_t* bnProcBufRes,  int8_t* llrRes ,  int8_t* llrProcBuf ) {
+   __m256i ymm0, ymm1, ymmRes0, ymmRes1;  
+        __m128i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m128i* p_llrProcBuf;
+        __m256i* p_llrProcBuf256; 
+        __m256i* p_llrRes; 
+// Process group with 1 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [0];
+    p_bnProcBufRes  = (__m256i*) &bnProcBufRes [0];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [0];
+    p_llrProcBuf256 = (__m256i*) &llrProcBuf   [0];
+    p_llrRes        = (__m256i*) &llrRes       [0];
+            for (int i=0,j=0;i<342;i++,j+=2) {
+             p_bnProcBufRes[i] = p_llrProcBuf256[i];
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j+1]);
+           ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j+1]);
+            ymmRes1 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [14592];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [14592];
+    p_llrRes        = (__m256i*) &llrRes       [14592];
+        for (int i=0,j=0;i<18;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [18432];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [15360];
+    p_llrRes        = (__m256i*) &llrRes       [15360];
+        for (int i=0,j=0;i<9;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [20736];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [15744];
+    p_llrRes        = (__m256i*) &llrRes       [15744];
+        for (int i=0,j=0;i<9;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [23424];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16128];
+    p_llrRes        = (__m256i*) &llrRes       [16128];
+        for (int i=0,j=0;i<9;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [26496];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16512];
+    p_llrRes        = (__m256i*) &llrRes       [16512];
+        for (int i=0,j=0;i<18;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [33408];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [17280];
+    p_llrRes        = (__m256i*) &llrRes       [17280];
+        for (int i=0,j=0;i<9;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 11 CNs 
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [37248];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [17664];
+    p_llrRes        = (__m256i*) &llrRes       [17664];
+            for (int i=0,j=0;i<9;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [41856];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [18048];
+    p_llrRes        = (__m256i*) &llrRes       [18048];
+        for (int i=0,j=0;i<9;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 14 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [46848];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [18432];
+    p_llrRes        = (__m256i*) &llrRes       [18432];
+        for (int i=0,j=0;i<9;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [52224];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [18816];
+    p_llrRes        = (__m256i*) &llrRes       [18816];
+        for (int i=0,j=0;i<9;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [58368];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [19200];
+    p_llrRes        = (__m256i*) &llrRes       [19200];
+            for (int i=0,j=0;i<9;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with <23 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [66816];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [19584];
+    p_llrRes        = (__m256i*) &llrRes       [19584];
+        for (int i=0,j=0;i<9;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z28_R15_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z28_R15_AVX2.c
new file mode 100644
index 0000000000..465742e608
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z28_R15_AVX2.c
@@ -0,0 +1,757 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProcPc_BG2_Z28_R15_AVX2(int8_t* bnProcBuf, int8_t* bnProcBufRes,  int8_t* llrRes ,  int8_t* llrProcBuf ) {
+   __m256i ymm0, ymm1, ymmRes0, ymmRes1;  
+        __m128i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m128i* p_llrProcBuf;
+        __m256i* p_llrProcBuf256; 
+        __m256i* p_llrRes; 
+// Process group with 1 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [0];
+    p_bnProcBufRes  = (__m256i*) &bnProcBufRes [0];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [0];
+    p_llrProcBuf256 = (__m256i*) &llrProcBuf   [0];
+    p_llrRes        = (__m256i*) &llrRes       [0];
+            for (int i=0,j=0;i<34;i++,j+=2) {
+             p_bnProcBufRes[i] = p_llrProcBuf256[i];
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j+1]);
+           ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j+1]);
+            ymmRes1 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [14592];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [14592];
+    p_llrRes        = (__m256i*) &llrRes       [14592];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [18432];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [15360];
+    p_llrRes        = (__m256i*) &llrRes       [15360];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [20736];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [15744];
+    p_llrRes        = (__m256i*) &llrRes       [15744];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [23424];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16128];
+    p_llrRes        = (__m256i*) &llrRes       [16128];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [26496];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16512];
+    p_llrRes        = (__m256i*) &llrRes       [16512];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [33408];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [17280];
+    p_llrRes        = (__m256i*) &llrRes       [17280];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 11 CNs 
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [37248];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [17664];
+    p_llrRes        = (__m256i*) &llrRes       [17664];
+            for (int i=0,j=0;i<1;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [41856];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [18048];
+    p_llrRes        = (__m256i*) &llrRes       [18048];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 14 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [46848];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [18432];
+    p_llrRes        = (__m256i*) &llrRes       [18432];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [52224];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [18816];
+    p_llrRes        = (__m256i*) &llrRes       [18816];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [58368];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [19200];
+    p_llrRes        = (__m256i*) &llrRes       [19200];
+            for (int i=0,j=0;i<1;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with <23 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [66816];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [19584];
+    p_llrRes        = (__m256i*) &llrRes       [19584];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z2_R15_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z2_R15_AVX2.c
new file mode 100644
index 0000000000..e93cdfcf11
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z2_R15_AVX2.c
@@ -0,0 +1,757 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProcPc_BG2_Z2_R15_AVX2(int8_t* bnProcBuf, int8_t* bnProcBufRes,  int8_t* llrRes ,  int8_t* llrProcBuf ) {
+   __m256i ymm0, ymm1, ymmRes0, ymmRes1;  
+        __m128i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m128i* p_llrProcBuf;
+        __m256i* p_llrProcBuf256; 
+        __m256i* p_llrRes; 
+// Process group with 1 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [0];
+    p_bnProcBufRes  = (__m256i*) &bnProcBufRes [0];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [0];
+    p_llrProcBuf256 = (__m256i*) &llrProcBuf   [0];
+    p_llrRes        = (__m256i*) &llrRes       [0];
+            for (int i=0,j=0;i<3;i++,j+=2) {
+             p_bnProcBufRes[i] = p_llrProcBuf256[i];
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j+1]);
+           ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j+1]);
+            ymmRes1 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [14592];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [14592];
+    p_llrRes        = (__m256i*) &llrRes       [14592];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [18432];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [15360];
+    p_llrRes        = (__m256i*) &llrRes       [15360];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [20736];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [15744];
+    p_llrRes        = (__m256i*) &llrRes       [15744];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [23424];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16128];
+    p_llrRes        = (__m256i*) &llrRes       [16128];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [26496];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16512];
+    p_llrRes        = (__m256i*) &llrRes       [16512];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [33408];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [17280];
+    p_llrRes        = (__m256i*) &llrRes       [17280];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 11 CNs 
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [37248];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [17664];
+    p_llrRes        = (__m256i*) &llrRes       [17664];
+            for (int i=0,j=0;i<1;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [41856];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [18048];
+    p_llrRes        = (__m256i*) &llrRes       [18048];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 14 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [46848];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [18432];
+    p_llrRes        = (__m256i*) &llrRes       [18432];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [52224];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [18816];
+    p_llrRes        = (__m256i*) &llrRes       [18816];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [58368];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [19200];
+    p_llrRes        = (__m256i*) &llrRes       [19200];
+            for (int i=0,j=0;i<1;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with <23 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [66816];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [19584];
+    p_llrRes        = (__m256i*) &llrRes       [19584];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z30_R15_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z30_R15_AVX2.c
new file mode 100644
index 0000000000..8d060b7c79
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z30_R15_AVX2.c
@@ -0,0 +1,757 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProcPc_BG2_Z30_R15_AVX2(int8_t* bnProcBuf, int8_t* bnProcBufRes,  int8_t* llrRes ,  int8_t* llrProcBuf ) {
+   __m256i ymm0, ymm1, ymmRes0, ymmRes1;  
+        __m128i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m128i* p_llrProcBuf;
+        __m256i* p_llrProcBuf256; 
+        __m256i* p_llrRes; 
+// Process group with 1 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [0];
+    p_bnProcBufRes  = (__m256i*) &bnProcBufRes [0];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [0];
+    p_llrProcBuf256 = (__m256i*) &llrProcBuf   [0];
+    p_llrRes        = (__m256i*) &llrRes       [0];
+            for (int i=0,j=0;i<36;i++,j+=2) {
+             p_bnProcBufRes[i] = p_llrProcBuf256[i];
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j+1]);
+           ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j+1]);
+            ymmRes1 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [14592];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [14592];
+    p_llrRes        = (__m256i*) &llrRes       [14592];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [18432];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [15360];
+    p_llrRes        = (__m256i*) &llrRes       [15360];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [20736];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [15744];
+    p_llrRes        = (__m256i*) &llrRes       [15744];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [23424];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16128];
+    p_llrRes        = (__m256i*) &llrRes       [16128];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [26496];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16512];
+    p_llrRes        = (__m256i*) &llrRes       [16512];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [33408];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [17280];
+    p_llrRes        = (__m256i*) &llrRes       [17280];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 11 CNs 
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [37248];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [17664];
+    p_llrRes        = (__m256i*) &llrRes       [17664];
+            for (int i=0,j=0;i<1;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [41856];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [18048];
+    p_llrRes        = (__m256i*) &llrRes       [18048];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 14 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [46848];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [18432];
+    p_llrRes        = (__m256i*) &llrRes       [18432];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [52224];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [18816];
+    p_llrRes        = (__m256i*) &llrRes       [18816];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [58368];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [19200];
+    p_llrRes        = (__m256i*) &llrRes       [19200];
+            for (int i=0,j=0;i<1;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with <23 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [66816];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [19584];
+    p_llrRes        = (__m256i*) &llrRes       [19584];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z320_R15_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z320_R15_AVX2.c
new file mode 100644
index 0000000000..92268f3d53
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z320_R15_AVX2.c
@@ -0,0 +1,757 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProcPc_BG2_Z320_R15_AVX2(int8_t* bnProcBuf, int8_t* bnProcBufRes,  int8_t* llrRes ,  int8_t* llrProcBuf ) {
+   __m256i ymm0, ymm1, ymmRes0, ymmRes1;  
+        __m128i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m128i* p_llrProcBuf;
+        __m256i* p_llrProcBuf256; 
+        __m256i* p_llrRes; 
+// Process group with 1 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [0];
+    p_bnProcBufRes  = (__m256i*) &bnProcBufRes [0];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [0];
+    p_llrProcBuf256 = (__m256i*) &llrProcBuf   [0];
+    p_llrRes        = (__m256i*) &llrRes       [0];
+            for (int i=0,j=0;i<380;i++,j+=2) {
+             p_bnProcBufRes[i] = p_llrProcBuf256[i];
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j+1]);
+           ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j+1]);
+            ymmRes1 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [14592];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [14592];
+    p_llrRes        = (__m256i*) &llrRes       [14592];
+        for (int i=0,j=0;i<20;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [18432];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [15360];
+    p_llrRes        = (__m256i*) &llrRes       [15360];
+        for (int i=0,j=0;i<10;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [20736];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [15744];
+    p_llrRes        = (__m256i*) &llrRes       [15744];
+        for (int i=0,j=0;i<10;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [23424];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16128];
+    p_llrRes        = (__m256i*) &llrRes       [16128];
+        for (int i=0,j=0;i<10;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [26496];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16512];
+    p_llrRes        = (__m256i*) &llrRes       [16512];
+        for (int i=0,j=0;i<20;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [33408];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [17280];
+    p_llrRes        = (__m256i*) &llrRes       [17280];
+        for (int i=0,j=0;i<10;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 11 CNs 
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [37248];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [17664];
+    p_llrRes        = (__m256i*) &llrRes       [17664];
+            for (int i=0,j=0;i<10;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [41856];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [18048];
+    p_llrRes        = (__m256i*) &llrRes       [18048];
+        for (int i=0,j=0;i<10;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 14 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [46848];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [18432];
+    p_llrRes        = (__m256i*) &llrRes       [18432];
+        for (int i=0,j=0;i<10;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [52224];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [18816];
+    p_llrRes        = (__m256i*) &llrRes       [18816];
+        for (int i=0,j=0;i<10;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [58368];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [19200];
+    p_llrRes        = (__m256i*) &llrRes       [19200];
+            for (int i=0,j=0;i<10;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with <23 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [66816];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [19584];
+    p_llrRes        = (__m256i*) &llrRes       [19584];
+        for (int i=0,j=0;i<10;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z32_R15_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z32_R15_AVX2.c
new file mode 100644
index 0000000000..bfc4c0b52b
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z32_R15_AVX2.c
@@ -0,0 +1,757 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProcPc_BG2_Z32_R15_AVX2(int8_t* bnProcBuf, int8_t* bnProcBufRes,  int8_t* llrRes ,  int8_t* llrProcBuf ) {
+   __m256i ymm0, ymm1, ymmRes0, ymmRes1;  
+        __m128i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m128i* p_llrProcBuf;
+        __m256i* p_llrProcBuf256; 
+        __m256i* p_llrRes; 
+// Process group with 1 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [0];
+    p_bnProcBufRes  = (__m256i*) &bnProcBufRes [0];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [0];
+    p_llrProcBuf256 = (__m256i*) &llrProcBuf   [0];
+    p_llrRes        = (__m256i*) &llrRes       [0];
+            for (int i=0,j=0;i<38;i++,j+=2) {
+             p_bnProcBufRes[i] = p_llrProcBuf256[i];
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j+1]);
+           ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j+1]);
+            ymmRes1 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [14592];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [14592];
+    p_llrRes        = (__m256i*) &llrRes       [14592];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [18432];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [15360];
+    p_llrRes        = (__m256i*) &llrRes       [15360];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [20736];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [15744];
+    p_llrRes        = (__m256i*) &llrRes       [15744];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [23424];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16128];
+    p_llrRes        = (__m256i*) &llrRes       [16128];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [26496];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16512];
+    p_llrRes        = (__m256i*) &llrRes       [16512];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [33408];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [17280];
+    p_llrRes        = (__m256i*) &llrRes       [17280];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 11 CNs 
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [37248];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [17664];
+    p_llrRes        = (__m256i*) &llrRes       [17664];
+            for (int i=0,j=0;i<1;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [41856];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [18048];
+    p_llrRes        = (__m256i*) &llrRes       [18048];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 14 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [46848];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [18432];
+    p_llrRes        = (__m256i*) &llrRes       [18432];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [52224];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [18816];
+    p_llrRes        = (__m256i*) &llrRes       [18816];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [58368];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [19200];
+    p_llrRes        = (__m256i*) &llrRes       [19200];
+            for (int i=0,j=0;i<1;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with <23 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [66816];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [19584];
+    p_llrRes        = (__m256i*) &llrRes       [19584];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z352_R15_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z352_R15_AVX2.c
new file mode 100644
index 0000000000..2c6cc7b6b0
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z352_R15_AVX2.c
@@ -0,0 +1,757 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProcPc_BG2_Z352_R15_AVX2(int8_t* bnProcBuf, int8_t* bnProcBufRes,  int8_t* llrRes ,  int8_t* llrProcBuf ) {
+   __m256i ymm0, ymm1, ymmRes0, ymmRes1;  
+        __m128i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m128i* p_llrProcBuf;
+        __m256i* p_llrProcBuf256; 
+        __m256i* p_llrRes; 
+// Process group with 1 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [0];
+    p_bnProcBufRes  = (__m256i*) &bnProcBufRes [0];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [0];
+    p_llrProcBuf256 = (__m256i*) &llrProcBuf   [0];
+    p_llrRes        = (__m256i*) &llrRes       [0];
+            for (int i=0,j=0;i<418;i++,j+=2) {
+             p_bnProcBufRes[i] = p_llrProcBuf256[i];
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j+1]);
+           ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j+1]);
+            ymmRes1 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [14592];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [14592];
+    p_llrRes        = (__m256i*) &llrRes       [14592];
+        for (int i=0,j=0;i<22;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [18432];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [15360];
+    p_llrRes        = (__m256i*) &llrRes       [15360];
+        for (int i=0,j=0;i<11;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [20736];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [15744];
+    p_llrRes        = (__m256i*) &llrRes       [15744];
+        for (int i=0,j=0;i<11;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [23424];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16128];
+    p_llrRes        = (__m256i*) &llrRes       [16128];
+        for (int i=0,j=0;i<11;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [26496];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16512];
+    p_llrRes        = (__m256i*) &llrRes       [16512];
+        for (int i=0,j=0;i<22;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [33408];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [17280];
+    p_llrRes        = (__m256i*) &llrRes       [17280];
+        for (int i=0,j=0;i<11;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 11 CNs 
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [37248];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [17664];
+    p_llrRes        = (__m256i*) &llrRes       [17664];
+            for (int i=0,j=0;i<11;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [41856];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [18048];
+    p_llrRes        = (__m256i*) &llrRes       [18048];
+        for (int i=0,j=0;i<11;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 14 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [46848];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [18432];
+    p_llrRes        = (__m256i*) &llrRes       [18432];
+        for (int i=0,j=0;i<11;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [52224];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [18816];
+    p_llrRes        = (__m256i*) &llrRes       [18816];
+        for (int i=0,j=0;i<11;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [58368];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [19200];
+    p_llrRes        = (__m256i*) &llrRes       [19200];
+            for (int i=0,j=0;i<11;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with <23 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [66816];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [19584];
+    p_llrRes        = (__m256i*) &llrRes       [19584];
+        for (int i=0,j=0;i<11;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z36_R15_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z36_R15_AVX2.c
new file mode 100644
index 0000000000..ed4a0100a9
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z36_R15_AVX2.c
@@ -0,0 +1,757 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProcPc_BG2_Z36_R15_AVX2(int8_t* bnProcBuf, int8_t* bnProcBufRes,  int8_t* llrRes ,  int8_t* llrProcBuf ) {
+   __m256i ymm0, ymm1, ymmRes0, ymmRes1;  
+        __m128i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m128i* p_llrProcBuf;
+        __m256i* p_llrProcBuf256; 
+        __m256i* p_llrRes; 
+// Process group with 1 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [0];
+    p_bnProcBufRes  = (__m256i*) &bnProcBufRes [0];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [0];
+    p_llrProcBuf256 = (__m256i*) &llrProcBuf   [0];
+    p_llrRes        = (__m256i*) &llrRes       [0];
+            for (int i=0,j=0;i<43;i++,j+=2) {
+             p_bnProcBufRes[i] = p_llrProcBuf256[i];
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j+1]);
+           ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j+1]);
+            ymmRes1 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [14592];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [14592];
+    p_llrRes        = (__m256i*) &llrRes       [14592];
+        for (int i=0,j=0;i<3;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [18432];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [15360];
+    p_llrRes        = (__m256i*) &llrRes       [15360];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [20736];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [15744];
+    p_llrRes        = (__m256i*) &llrRes       [15744];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [23424];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16128];
+    p_llrRes        = (__m256i*) &llrRes       [16128];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [26496];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16512];
+    p_llrRes        = (__m256i*) &llrRes       [16512];
+        for (int i=0,j=0;i<3;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [33408];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [17280];
+    p_llrRes        = (__m256i*) &llrRes       [17280];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 11 CNs 
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [37248];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [17664];
+    p_llrRes        = (__m256i*) &llrRes       [17664];
+            for (int i=0,j=0;i<2;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [41856];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [18048];
+    p_llrRes        = (__m256i*) &llrRes       [18048];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 14 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [46848];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [18432];
+    p_llrRes        = (__m256i*) &llrRes       [18432];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [52224];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [18816];
+    p_llrRes        = (__m256i*) &llrRes       [18816];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [58368];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [19200];
+    p_llrRes        = (__m256i*) &llrRes       [19200];
+            for (int i=0,j=0;i<2;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with <23 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [66816];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [19584];
+    p_llrRes        = (__m256i*) &llrRes       [19584];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z384_R15_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z384_R15_AVX2.c
new file mode 100644
index 0000000000..a5c0f02b5b
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z384_R15_AVX2.c
@@ -0,0 +1,757 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProcPc_BG2_Z384_R15_AVX2(int8_t* bnProcBuf, int8_t* bnProcBufRes,  int8_t* llrRes ,  int8_t* llrProcBuf ) {
+   __m256i ymm0, ymm1, ymmRes0, ymmRes1;  
+        __m128i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m128i* p_llrProcBuf;
+        __m256i* p_llrProcBuf256; 
+        __m256i* p_llrRes; 
+// Process group with 1 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [0];
+    p_bnProcBufRes  = (__m256i*) &bnProcBufRes [0];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [0];
+    p_llrProcBuf256 = (__m256i*) &llrProcBuf   [0];
+    p_llrRes        = (__m256i*) &llrRes       [0];
+            for (int i=0,j=0;i<456;i++,j+=2) {
+             p_bnProcBufRes[i] = p_llrProcBuf256[i];
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j+1]);
+           ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j+1]);
+            ymmRes1 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [14592];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [14592];
+    p_llrRes        = (__m256i*) &llrRes       [14592];
+        for (int i=0,j=0;i<24;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [18432];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [15360];
+    p_llrRes        = (__m256i*) &llrRes       [15360];
+        for (int i=0,j=0;i<12;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [20736];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [15744];
+    p_llrRes        = (__m256i*) &llrRes       [15744];
+        for (int i=0,j=0;i<12;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [23424];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16128];
+    p_llrRes        = (__m256i*) &llrRes       [16128];
+        for (int i=0,j=0;i<12;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [26496];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16512];
+    p_llrRes        = (__m256i*) &llrRes       [16512];
+        for (int i=0,j=0;i<24;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [33408];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [17280];
+    p_llrRes        = (__m256i*) &llrRes       [17280];
+        for (int i=0,j=0;i<12;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 11 CNs 
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [37248];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [17664];
+    p_llrRes        = (__m256i*) &llrRes       [17664];
+            for (int i=0,j=0;i<12;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [41856];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [18048];
+    p_llrRes        = (__m256i*) &llrRes       [18048];
+        for (int i=0,j=0;i<12;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 14 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [46848];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [18432];
+    p_llrRes        = (__m256i*) &llrRes       [18432];
+        for (int i=0,j=0;i<12;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [52224];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [18816];
+    p_llrRes        = (__m256i*) &llrRes       [18816];
+        for (int i=0,j=0;i<12;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [58368];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [19200];
+    p_llrRes        = (__m256i*) &llrRes       [19200];
+            for (int i=0,j=0;i<12;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with <23 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [66816];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [19584];
+    p_llrRes        = (__m256i*) &llrRes       [19584];
+        for (int i=0,j=0;i<12;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z3_R15_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z3_R15_AVX2.c
new file mode 100644
index 0000000000..43e8bcd7de
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z3_R15_AVX2.c
@@ -0,0 +1,757 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProcPc_BG2_Z3_R15_AVX2(int8_t* bnProcBuf, int8_t* bnProcBufRes,  int8_t* llrRes ,  int8_t* llrProcBuf ) {
+   __m256i ymm0, ymm1, ymmRes0, ymmRes1;  
+        __m128i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m128i* p_llrProcBuf;
+        __m256i* p_llrProcBuf256; 
+        __m256i* p_llrRes; 
+// Process group with 1 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [0];
+    p_bnProcBufRes  = (__m256i*) &bnProcBufRes [0];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [0];
+    p_llrProcBuf256 = (__m256i*) &llrProcBuf   [0];
+    p_llrRes        = (__m256i*) &llrRes       [0];
+            for (int i=0,j=0;i<4;i++,j+=2) {
+             p_bnProcBufRes[i] = p_llrProcBuf256[i];
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j+1]);
+           ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j+1]);
+            ymmRes1 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [14592];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [14592];
+    p_llrRes        = (__m256i*) &llrRes       [14592];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [18432];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [15360];
+    p_llrRes        = (__m256i*) &llrRes       [15360];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [20736];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [15744];
+    p_llrRes        = (__m256i*) &llrRes       [15744];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [23424];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16128];
+    p_llrRes        = (__m256i*) &llrRes       [16128];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [26496];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16512];
+    p_llrRes        = (__m256i*) &llrRes       [16512];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [33408];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [17280];
+    p_llrRes        = (__m256i*) &llrRes       [17280];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 11 CNs 
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [37248];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [17664];
+    p_llrRes        = (__m256i*) &llrRes       [17664];
+            for (int i=0,j=0;i<1;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [41856];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [18048];
+    p_llrRes        = (__m256i*) &llrRes       [18048];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 14 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [46848];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [18432];
+    p_llrRes        = (__m256i*) &llrRes       [18432];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [52224];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [18816];
+    p_llrRes        = (__m256i*) &llrRes       [18816];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [58368];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [19200];
+    p_llrRes        = (__m256i*) &llrRes       [19200];
+            for (int i=0,j=0;i<1;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with <23 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [66816];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [19584];
+    p_llrRes        = (__m256i*) &llrRes       [19584];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z40_R15_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z40_R15_AVX2.c
new file mode 100644
index 0000000000..24438b13cd
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z40_R15_AVX2.c
@@ -0,0 +1,757 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProcPc_BG2_Z40_R15_AVX2(int8_t* bnProcBuf, int8_t* bnProcBufRes,  int8_t* llrRes ,  int8_t* llrProcBuf ) {
+   __m256i ymm0, ymm1, ymmRes0, ymmRes1;  
+        __m128i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m128i* p_llrProcBuf;
+        __m256i* p_llrProcBuf256; 
+        __m256i* p_llrRes; 
+// Process group with 1 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [0];
+    p_bnProcBufRes  = (__m256i*) &bnProcBufRes [0];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [0];
+    p_llrProcBuf256 = (__m256i*) &llrProcBuf   [0];
+    p_llrRes        = (__m256i*) &llrRes       [0];
+            for (int i=0,j=0;i<48;i++,j+=2) {
+             p_bnProcBufRes[i] = p_llrProcBuf256[i];
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j+1]);
+           ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j+1]);
+            ymmRes1 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [14592];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [14592];
+    p_llrRes        = (__m256i*) &llrRes       [14592];
+        for (int i=0,j=0;i<3;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [18432];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [15360];
+    p_llrRes        = (__m256i*) &llrRes       [15360];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [20736];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [15744];
+    p_llrRes        = (__m256i*) &llrRes       [15744];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [23424];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16128];
+    p_llrRes        = (__m256i*) &llrRes       [16128];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [26496];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16512];
+    p_llrRes        = (__m256i*) &llrRes       [16512];
+        for (int i=0,j=0;i<3;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [33408];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [17280];
+    p_llrRes        = (__m256i*) &llrRes       [17280];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 11 CNs 
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [37248];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [17664];
+    p_llrRes        = (__m256i*) &llrRes       [17664];
+            for (int i=0,j=0;i<2;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [41856];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [18048];
+    p_llrRes        = (__m256i*) &llrRes       [18048];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 14 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [46848];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [18432];
+    p_llrRes        = (__m256i*) &llrRes       [18432];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [52224];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [18816];
+    p_llrRes        = (__m256i*) &llrRes       [18816];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [58368];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [19200];
+    p_llrRes        = (__m256i*) &llrRes       [19200];
+            for (int i=0,j=0;i<2;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with <23 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [66816];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [19584];
+    p_llrRes        = (__m256i*) &llrRes       [19584];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z44_R15_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z44_R15_AVX2.c
new file mode 100644
index 0000000000..0f324af960
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z44_R15_AVX2.c
@@ -0,0 +1,757 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProcPc_BG2_Z44_R15_AVX2(int8_t* bnProcBuf, int8_t* bnProcBufRes,  int8_t* llrRes ,  int8_t* llrProcBuf ) {
+   __m256i ymm0, ymm1, ymmRes0, ymmRes1;  
+        __m128i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m128i* p_llrProcBuf;
+        __m256i* p_llrProcBuf256; 
+        __m256i* p_llrRes; 
+// Process group with 1 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [0];
+    p_bnProcBufRes  = (__m256i*) &bnProcBufRes [0];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [0];
+    p_llrProcBuf256 = (__m256i*) &llrProcBuf   [0];
+    p_llrRes        = (__m256i*) &llrRes       [0];
+            for (int i=0,j=0;i<53;i++,j+=2) {
+             p_bnProcBufRes[i] = p_llrProcBuf256[i];
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j+1]);
+           ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j+1]);
+            ymmRes1 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [14592];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [14592];
+    p_llrRes        = (__m256i*) &llrRes       [14592];
+        for (int i=0,j=0;i<3;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [18432];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [15360];
+    p_llrRes        = (__m256i*) &llrRes       [15360];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [20736];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [15744];
+    p_llrRes        = (__m256i*) &llrRes       [15744];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [23424];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16128];
+    p_llrRes        = (__m256i*) &llrRes       [16128];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [26496];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16512];
+    p_llrRes        = (__m256i*) &llrRes       [16512];
+        for (int i=0,j=0;i<3;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [33408];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [17280];
+    p_llrRes        = (__m256i*) &llrRes       [17280];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 11 CNs 
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [37248];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [17664];
+    p_llrRes        = (__m256i*) &llrRes       [17664];
+            for (int i=0,j=0;i<2;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [41856];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [18048];
+    p_llrRes        = (__m256i*) &llrRes       [18048];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 14 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [46848];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [18432];
+    p_llrRes        = (__m256i*) &llrRes       [18432];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [52224];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [18816];
+    p_llrRes        = (__m256i*) &llrRes       [18816];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [58368];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [19200];
+    p_llrRes        = (__m256i*) &llrRes       [19200];
+            for (int i=0,j=0;i<2;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with <23 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [66816];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [19584];
+    p_llrRes        = (__m256i*) &llrRes       [19584];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z48_R15_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z48_R15_AVX2.c
new file mode 100644
index 0000000000..9e88e7b0ed
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z48_R15_AVX2.c
@@ -0,0 +1,757 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProcPc_BG2_Z48_R15_AVX2(int8_t* bnProcBuf, int8_t* bnProcBufRes,  int8_t* llrRes ,  int8_t* llrProcBuf ) {
+   __m256i ymm0, ymm1, ymmRes0, ymmRes1;  
+        __m128i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m128i* p_llrProcBuf;
+        __m256i* p_llrProcBuf256; 
+        __m256i* p_llrRes; 
+// Process group with 1 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [0];
+    p_bnProcBufRes  = (__m256i*) &bnProcBufRes [0];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [0];
+    p_llrProcBuf256 = (__m256i*) &llrProcBuf   [0];
+    p_llrRes        = (__m256i*) &llrRes       [0];
+            for (int i=0,j=0;i<57;i++,j+=2) {
+             p_bnProcBufRes[i] = p_llrProcBuf256[i];
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j+1]);
+           ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j+1]);
+            ymmRes1 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [14592];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [14592];
+    p_llrRes        = (__m256i*) &llrRes       [14592];
+        for (int i=0,j=0;i<3;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [18432];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [15360];
+    p_llrRes        = (__m256i*) &llrRes       [15360];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [20736];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [15744];
+    p_llrRes        = (__m256i*) &llrRes       [15744];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [23424];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16128];
+    p_llrRes        = (__m256i*) &llrRes       [16128];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [26496];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16512];
+    p_llrRes        = (__m256i*) &llrRes       [16512];
+        for (int i=0,j=0;i<3;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [33408];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [17280];
+    p_llrRes        = (__m256i*) &llrRes       [17280];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 11 CNs 
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [37248];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [17664];
+    p_llrRes        = (__m256i*) &llrRes       [17664];
+            for (int i=0,j=0;i<2;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [41856];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [18048];
+    p_llrRes        = (__m256i*) &llrRes       [18048];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 14 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [46848];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [18432];
+    p_llrRes        = (__m256i*) &llrRes       [18432];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [52224];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [18816];
+    p_llrRes        = (__m256i*) &llrRes       [18816];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [58368];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [19200];
+    p_llrRes        = (__m256i*) &llrRes       [19200];
+            for (int i=0,j=0;i<2;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with <23 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [66816];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [19584];
+    p_llrRes        = (__m256i*) &llrRes       [19584];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z4_R15_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z4_R15_AVX2.c
new file mode 100644
index 0000000000..12597e8f2f
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z4_R15_AVX2.c
@@ -0,0 +1,757 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProcPc_BG2_Z4_R15_AVX2(int8_t* bnProcBuf, int8_t* bnProcBufRes,  int8_t* llrRes ,  int8_t* llrProcBuf ) {
+   __m256i ymm0, ymm1, ymmRes0, ymmRes1;  
+        __m128i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m128i* p_llrProcBuf;
+        __m256i* p_llrProcBuf256; 
+        __m256i* p_llrRes; 
+// Process group with 1 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [0];
+    p_bnProcBufRes  = (__m256i*) &bnProcBufRes [0];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [0];
+    p_llrProcBuf256 = (__m256i*) &llrProcBuf   [0];
+    p_llrRes        = (__m256i*) &llrRes       [0];
+            for (int i=0,j=0;i<5;i++,j+=2) {
+             p_bnProcBufRes[i] = p_llrProcBuf256[i];
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j+1]);
+           ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j+1]);
+            ymmRes1 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [14592];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [14592];
+    p_llrRes        = (__m256i*) &llrRes       [14592];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [18432];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [15360];
+    p_llrRes        = (__m256i*) &llrRes       [15360];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [20736];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [15744];
+    p_llrRes        = (__m256i*) &llrRes       [15744];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [23424];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16128];
+    p_llrRes        = (__m256i*) &llrRes       [16128];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [26496];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16512];
+    p_llrRes        = (__m256i*) &llrRes       [16512];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [33408];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [17280];
+    p_llrRes        = (__m256i*) &llrRes       [17280];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 11 CNs 
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [37248];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [17664];
+    p_llrRes        = (__m256i*) &llrRes       [17664];
+            for (int i=0,j=0;i<1;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [41856];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [18048];
+    p_llrRes        = (__m256i*) &llrRes       [18048];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 14 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [46848];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [18432];
+    p_llrRes        = (__m256i*) &llrRes       [18432];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [52224];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [18816];
+    p_llrRes        = (__m256i*) &llrRes       [18816];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [58368];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [19200];
+    p_llrRes        = (__m256i*) &llrRes       [19200];
+            for (int i=0,j=0;i<1;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with <23 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [66816];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [19584];
+    p_llrRes        = (__m256i*) &llrRes       [19584];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z52_R15_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z52_R15_AVX2.c
new file mode 100644
index 0000000000..6b6566f36e
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z52_R15_AVX2.c
@@ -0,0 +1,757 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProcPc_BG2_Z52_R15_AVX2(int8_t* bnProcBuf, int8_t* bnProcBufRes,  int8_t* llrRes ,  int8_t* llrProcBuf ) {
+   __m256i ymm0, ymm1, ymmRes0, ymmRes1;  
+        __m128i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m128i* p_llrProcBuf;
+        __m256i* p_llrProcBuf256; 
+        __m256i* p_llrRes; 
+// Process group with 1 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [0];
+    p_bnProcBufRes  = (__m256i*) &bnProcBufRes [0];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [0];
+    p_llrProcBuf256 = (__m256i*) &llrProcBuf   [0];
+    p_llrRes        = (__m256i*) &llrRes       [0];
+            for (int i=0,j=0;i<62;i++,j+=2) {
+             p_bnProcBufRes[i] = p_llrProcBuf256[i];
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j+1]);
+           ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j+1]);
+            ymmRes1 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [14592];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [14592];
+    p_llrRes        = (__m256i*) &llrRes       [14592];
+        for (int i=0,j=0;i<4;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [18432];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [15360];
+    p_llrRes        = (__m256i*) &llrRes       [15360];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [20736];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [15744];
+    p_llrRes        = (__m256i*) &llrRes       [15744];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [23424];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16128];
+    p_llrRes        = (__m256i*) &llrRes       [16128];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [26496];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16512];
+    p_llrRes        = (__m256i*) &llrRes       [16512];
+        for (int i=0,j=0;i<4;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [33408];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [17280];
+    p_llrRes        = (__m256i*) &llrRes       [17280];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 11 CNs 
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [37248];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [17664];
+    p_llrRes        = (__m256i*) &llrRes       [17664];
+            for (int i=0,j=0;i<2;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [41856];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [18048];
+    p_llrRes        = (__m256i*) &llrRes       [18048];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 14 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [46848];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [18432];
+    p_llrRes        = (__m256i*) &llrRes       [18432];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [52224];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [18816];
+    p_llrRes        = (__m256i*) &llrRes       [18816];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [58368];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [19200];
+    p_llrRes        = (__m256i*) &llrRes       [19200];
+            for (int i=0,j=0;i<2;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with <23 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [66816];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [19584];
+    p_llrRes        = (__m256i*) &llrRes       [19584];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z56_R15_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z56_R15_AVX2.c
new file mode 100644
index 0000000000..b1cce64577
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z56_R15_AVX2.c
@@ -0,0 +1,757 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProcPc_BG2_Z56_R15_AVX2(int8_t* bnProcBuf, int8_t* bnProcBufRes,  int8_t* llrRes ,  int8_t* llrProcBuf ) {
+   __m256i ymm0, ymm1, ymmRes0, ymmRes1;  
+        __m128i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m128i* p_llrProcBuf;
+        __m256i* p_llrProcBuf256; 
+        __m256i* p_llrRes; 
+// Process group with 1 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [0];
+    p_bnProcBufRes  = (__m256i*) &bnProcBufRes [0];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [0];
+    p_llrProcBuf256 = (__m256i*) &llrProcBuf   [0];
+    p_llrRes        = (__m256i*) &llrRes       [0];
+            for (int i=0,j=0;i<67;i++,j+=2) {
+             p_bnProcBufRes[i] = p_llrProcBuf256[i];
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j+1]);
+           ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j+1]);
+            ymmRes1 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [14592];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [14592];
+    p_llrRes        = (__m256i*) &llrRes       [14592];
+        for (int i=0,j=0;i<4;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [18432];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [15360];
+    p_llrRes        = (__m256i*) &llrRes       [15360];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [20736];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [15744];
+    p_llrRes        = (__m256i*) &llrRes       [15744];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [23424];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16128];
+    p_llrRes        = (__m256i*) &llrRes       [16128];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [26496];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16512];
+    p_llrRes        = (__m256i*) &llrRes       [16512];
+        for (int i=0,j=0;i<4;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [33408];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [17280];
+    p_llrRes        = (__m256i*) &llrRes       [17280];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 11 CNs 
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [37248];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [17664];
+    p_llrRes        = (__m256i*) &llrRes       [17664];
+            for (int i=0,j=0;i<2;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [41856];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [18048];
+    p_llrRes        = (__m256i*) &llrRes       [18048];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 14 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [46848];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [18432];
+    p_llrRes        = (__m256i*) &llrRes       [18432];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [52224];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [18816];
+    p_llrRes        = (__m256i*) &llrRes       [18816];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [58368];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [19200];
+    p_llrRes        = (__m256i*) &llrRes       [19200];
+            for (int i=0,j=0;i<2;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with <23 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [66816];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [19584];
+    p_llrRes        = (__m256i*) &llrRes       [19584];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z5_R15_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z5_R15_AVX2.c
new file mode 100644
index 0000000000..5991558809
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z5_R15_AVX2.c
@@ -0,0 +1,757 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProcPc_BG2_Z5_R15_AVX2(int8_t* bnProcBuf, int8_t* bnProcBufRes,  int8_t* llrRes ,  int8_t* llrProcBuf ) {
+   __m256i ymm0, ymm1, ymmRes0, ymmRes1;  
+        __m128i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m128i* p_llrProcBuf;
+        __m256i* p_llrProcBuf256; 
+        __m256i* p_llrRes; 
+// Process group with 1 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [0];
+    p_bnProcBufRes  = (__m256i*) &bnProcBufRes [0];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [0];
+    p_llrProcBuf256 = (__m256i*) &llrProcBuf   [0];
+    p_llrRes        = (__m256i*) &llrRes       [0];
+            for (int i=0,j=0;i<6;i++,j+=2) {
+             p_bnProcBufRes[i] = p_llrProcBuf256[i];
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j+1]);
+           ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j+1]);
+            ymmRes1 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [14592];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [14592];
+    p_llrRes        = (__m256i*) &llrRes       [14592];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [18432];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [15360];
+    p_llrRes        = (__m256i*) &llrRes       [15360];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [20736];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [15744];
+    p_llrRes        = (__m256i*) &llrRes       [15744];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [23424];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16128];
+    p_llrRes        = (__m256i*) &llrRes       [16128];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [26496];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16512];
+    p_llrRes        = (__m256i*) &llrRes       [16512];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [33408];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [17280];
+    p_llrRes        = (__m256i*) &llrRes       [17280];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 11 CNs 
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [37248];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [17664];
+    p_llrRes        = (__m256i*) &llrRes       [17664];
+            for (int i=0,j=0;i<1;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [41856];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [18048];
+    p_llrRes        = (__m256i*) &llrRes       [18048];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 14 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [46848];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [18432];
+    p_llrRes        = (__m256i*) &llrRes       [18432];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [52224];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [18816];
+    p_llrRes        = (__m256i*) &llrRes       [18816];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [58368];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [19200];
+    p_llrRes        = (__m256i*) &llrRes       [19200];
+            for (int i=0,j=0;i<1;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with <23 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [66816];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [19584];
+    p_llrRes        = (__m256i*) &llrRes       [19584];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z60_R15_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z60_R15_AVX2.c
new file mode 100644
index 0000000000..9c83e7d431
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z60_R15_AVX2.c
@@ -0,0 +1,757 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProcPc_BG2_Z60_R15_AVX2(int8_t* bnProcBuf, int8_t* bnProcBufRes,  int8_t* llrRes ,  int8_t* llrProcBuf ) {
+   __m256i ymm0, ymm1, ymmRes0, ymmRes1;  
+        __m128i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m128i* p_llrProcBuf;
+        __m256i* p_llrProcBuf256; 
+        __m256i* p_llrRes; 
+// Process group with 1 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [0];
+    p_bnProcBufRes  = (__m256i*) &bnProcBufRes [0];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [0];
+    p_llrProcBuf256 = (__m256i*) &llrProcBuf   [0];
+    p_llrRes        = (__m256i*) &llrRes       [0];
+            for (int i=0,j=0;i<72;i++,j+=2) {
+             p_bnProcBufRes[i] = p_llrProcBuf256[i];
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j+1]);
+           ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j+1]);
+            ymmRes1 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [14592];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [14592];
+    p_llrRes        = (__m256i*) &llrRes       [14592];
+        for (int i=0,j=0;i<4;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [18432];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [15360];
+    p_llrRes        = (__m256i*) &llrRes       [15360];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [20736];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [15744];
+    p_llrRes        = (__m256i*) &llrRes       [15744];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [23424];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16128];
+    p_llrRes        = (__m256i*) &llrRes       [16128];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [26496];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16512];
+    p_llrRes        = (__m256i*) &llrRes       [16512];
+        for (int i=0,j=0;i<4;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [33408];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [17280];
+    p_llrRes        = (__m256i*) &llrRes       [17280];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 11 CNs 
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [37248];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [17664];
+    p_llrRes        = (__m256i*) &llrRes       [17664];
+            for (int i=0,j=0;i<2;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [41856];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [18048];
+    p_llrRes        = (__m256i*) &llrRes       [18048];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 14 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [46848];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [18432];
+    p_llrRes        = (__m256i*) &llrRes       [18432];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [52224];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [18816];
+    p_llrRes        = (__m256i*) &llrRes       [18816];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [58368];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [19200];
+    p_llrRes        = (__m256i*) &llrRes       [19200];
+            for (int i=0,j=0;i<2;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with <23 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [66816];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [19584];
+    p_llrRes        = (__m256i*) &llrRes       [19584];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z64_R15_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z64_R15_AVX2.c
new file mode 100644
index 0000000000..9dd53e1642
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z64_R15_AVX2.c
@@ -0,0 +1,757 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProcPc_BG2_Z64_R15_AVX2(int8_t* bnProcBuf, int8_t* bnProcBufRes,  int8_t* llrRes ,  int8_t* llrProcBuf ) {
+   __m256i ymm0, ymm1, ymmRes0, ymmRes1;  
+        __m128i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m128i* p_llrProcBuf;
+        __m256i* p_llrProcBuf256; 
+        __m256i* p_llrRes; 
+// Process group with 1 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [0];
+    p_bnProcBufRes  = (__m256i*) &bnProcBufRes [0];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [0];
+    p_llrProcBuf256 = (__m256i*) &llrProcBuf   [0];
+    p_llrRes        = (__m256i*) &llrRes       [0];
+            for (int i=0,j=0;i<76;i++,j+=2) {
+             p_bnProcBufRes[i] = p_llrProcBuf256[i];
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j+1]);
+           ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j+1]);
+            ymmRes1 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [14592];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [14592];
+    p_llrRes        = (__m256i*) &llrRes       [14592];
+        for (int i=0,j=0;i<4;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [18432];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [15360];
+    p_llrRes        = (__m256i*) &llrRes       [15360];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [20736];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [15744];
+    p_llrRes        = (__m256i*) &llrRes       [15744];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [23424];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16128];
+    p_llrRes        = (__m256i*) &llrRes       [16128];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [26496];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16512];
+    p_llrRes        = (__m256i*) &llrRes       [16512];
+        for (int i=0,j=0;i<4;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [33408];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [17280];
+    p_llrRes        = (__m256i*) &llrRes       [17280];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 11 CNs 
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [37248];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [17664];
+    p_llrRes        = (__m256i*) &llrRes       [17664];
+            for (int i=0,j=0;i<2;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [41856];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [18048];
+    p_llrRes        = (__m256i*) &llrRes       [18048];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 14 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [46848];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [18432];
+    p_llrRes        = (__m256i*) &llrRes       [18432];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [52224];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [18816];
+    p_llrRes        = (__m256i*) &llrRes       [18816];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [58368];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [19200];
+    p_llrRes        = (__m256i*) &llrRes       [19200];
+            for (int i=0,j=0;i<2;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with <23 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [66816];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [19584];
+    p_llrRes        = (__m256i*) &llrRes       [19584];
+        for (int i=0,j=0;i<2;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z6_R15_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z6_R15_AVX2.c
new file mode 100644
index 0000000000..b7e769a154
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z6_R15_AVX2.c
@@ -0,0 +1,757 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProcPc_BG2_Z6_R15_AVX2(int8_t* bnProcBuf, int8_t* bnProcBufRes,  int8_t* llrRes ,  int8_t* llrProcBuf ) {
+   __m256i ymm0, ymm1, ymmRes0, ymmRes1;  
+        __m128i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m128i* p_llrProcBuf;
+        __m256i* p_llrProcBuf256; 
+        __m256i* p_llrRes; 
+// Process group with 1 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [0];
+    p_bnProcBufRes  = (__m256i*) &bnProcBufRes [0];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [0];
+    p_llrProcBuf256 = (__m256i*) &llrProcBuf   [0];
+    p_llrRes        = (__m256i*) &llrRes       [0];
+            for (int i=0,j=0;i<8;i++,j+=2) {
+             p_bnProcBufRes[i] = p_llrProcBuf256[i];
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j+1]);
+           ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j+1]);
+            ymmRes1 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [14592];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [14592];
+    p_llrRes        = (__m256i*) &llrRes       [14592];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [18432];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [15360];
+    p_llrRes        = (__m256i*) &llrRes       [15360];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [20736];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [15744];
+    p_llrRes        = (__m256i*) &llrRes       [15744];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [23424];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16128];
+    p_llrRes        = (__m256i*) &llrRes       [16128];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [26496];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16512];
+    p_llrRes        = (__m256i*) &llrRes       [16512];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [33408];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [17280];
+    p_llrRes        = (__m256i*) &llrRes       [17280];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 11 CNs 
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [37248];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [17664];
+    p_llrRes        = (__m256i*) &llrRes       [17664];
+            for (int i=0,j=0;i<1;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [41856];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [18048];
+    p_llrRes        = (__m256i*) &llrRes       [18048];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 14 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [46848];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [18432];
+    p_llrRes        = (__m256i*) &llrRes       [18432];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [52224];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [18816];
+    p_llrRes        = (__m256i*) &llrRes       [18816];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [58368];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [19200];
+    p_llrRes        = (__m256i*) &llrRes       [19200];
+            for (int i=0,j=0;i<1;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with <23 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [66816];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [19584];
+    p_llrRes        = (__m256i*) &llrRes       [19584];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z72_R15_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z72_R15_AVX2.c
new file mode 100644
index 0000000000..749b21d603
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z72_R15_AVX2.c
@@ -0,0 +1,757 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProcPc_BG2_Z72_R15_AVX2(int8_t* bnProcBuf, int8_t* bnProcBufRes,  int8_t* llrRes ,  int8_t* llrProcBuf ) {
+   __m256i ymm0, ymm1, ymmRes0, ymmRes1;  
+        __m128i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m128i* p_llrProcBuf;
+        __m256i* p_llrProcBuf256; 
+        __m256i* p_llrRes; 
+// Process group with 1 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [0];
+    p_bnProcBufRes  = (__m256i*) &bnProcBufRes [0];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [0];
+    p_llrProcBuf256 = (__m256i*) &llrProcBuf   [0];
+    p_llrRes        = (__m256i*) &llrRes       [0];
+            for (int i=0,j=0;i<86;i++,j+=2) {
+             p_bnProcBufRes[i] = p_llrProcBuf256[i];
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j+1]);
+           ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j+1]);
+            ymmRes1 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [14592];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [14592];
+    p_llrRes        = (__m256i*) &llrRes       [14592];
+        for (int i=0,j=0;i<5;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [18432];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [15360];
+    p_llrRes        = (__m256i*) &llrRes       [15360];
+        for (int i=0,j=0;i<3;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [20736];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [15744];
+    p_llrRes        = (__m256i*) &llrRes       [15744];
+        for (int i=0,j=0;i<3;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [23424];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16128];
+    p_llrRes        = (__m256i*) &llrRes       [16128];
+        for (int i=0,j=0;i<3;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [26496];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16512];
+    p_llrRes        = (__m256i*) &llrRes       [16512];
+        for (int i=0,j=0;i<5;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [33408];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [17280];
+    p_llrRes        = (__m256i*) &llrRes       [17280];
+        for (int i=0,j=0;i<3;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 11 CNs 
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [37248];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [17664];
+    p_llrRes        = (__m256i*) &llrRes       [17664];
+            for (int i=0,j=0;i<3;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [41856];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [18048];
+    p_llrRes        = (__m256i*) &llrRes       [18048];
+        for (int i=0,j=0;i<3;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 14 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [46848];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [18432];
+    p_llrRes        = (__m256i*) &llrRes       [18432];
+        for (int i=0,j=0;i<3;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [52224];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [18816];
+    p_llrRes        = (__m256i*) &llrRes       [18816];
+        for (int i=0,j=0;i<3;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [58368];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [19200];
+    p_llrRes        = (__m256i*) &llrRes       [19200];
+            for (int i=0,j=0;i<3;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with <23 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [66816];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [19584];
+    p_llrRes        = (__m256i*) &llrRes       [19584];
+        for (int i=0,j=0;i<3;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z7_R15_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z7_R15_AVX2.c
new file mode 100644
index 0000000000..ba4a638274
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z7_R15_AVX2.c
@@ -0,0 +1,757 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProcPc_BG2_Z7_R15_AVX2(int8_t* bnProcBuf, int8_t* bnProcBufRes,  int8_t* llrRes ,  int8_t* llrProcBuf ) {
+   __m256i ymm0, ymm1, ymmRes0, ymmRes1;  
+        __m128i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m128i* p_llrProcBuf;
+        __m256i* p_llrProcBuf256; 
+        __m256i* p_llrRes; 
+// Process group with 1 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [0];
+    p_bnProcBufRes  = (__m256i*) &bnProcBufRes [0];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [0];
+    p_llrProcBuf256 = (__m256i*) &llrProcBuf   [0];
+    p_llrRes        = (__m256i*) &llrRes       [0];
+            for (int i=0,j=0;i<9;i++,j+=2) {
+             p_bnProcBufRes[i] = p_llrProcBuf256[i];
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j+1]);
+           ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j+1]);
+            ymmRes1 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [14592];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [14592];
+    p_llrRes        = (__m256i*) &llrRes       [14592];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [18432];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [15360];
+    p_llrRes        = (__m256i*) &llrRes       [15360];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [20736];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [15744];
+    p_llrRes        = (__m256i*) &llrRes       [15744];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [23424];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16128];
+    p_llrRes        = (__m256i*) &llrRes       [16128];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [26496];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16512];
+    p_llrRes        = (__m256i*) &llrRes       [16512];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [33408];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [17280];
+    p_llrRes        = (__m256i*) &llrRes       [17280];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 11 CNs 
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [37248];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [17664];
+    p_llrRes        = (__m256i*) &llrRes       [17664];
+            for (int i=0,j=0;i<1;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [41856];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [18048];
+    p_llrRes        = (__m256i*) &llrRes       [18048];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 14 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [46848];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [18432];
+    p_llrRes        = (__m256i*) &llrRes       [18432];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [52224];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [18816];
+    p_llrRes        = (__m256i*) &llrRes       [18816];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [58368];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [19200];
+    p_llrRes        = (__m256i*) &llrRes       [19200];
+            for (int i=0,j=0;i<1;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with <23 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [66816];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [19584];
+    p_llrRes        = (__m256i*) &llrRes       [19584];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z80_R15_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z80_R15_AVX2.c
new file mode 100644
index 0000000000..b60d9c6ad4
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z80_R15_AVX2.c
@@ -0,0 +1,757 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProcPc_BG2_Z80_R15_AVX2(int8_t* bnProcBuf, int8_t* bnProcBufRes,  int8_t* llrRes ,  int8_t* llrProcBuf ) {
+   __m256i ymm0, ymm1, ymmRes0, ymmRes1;  
+        __m128i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m128i* p_llrProcBuf;
+        __m256i* p_llrProcBuf256; 
+        __m256i* p_llrRes; 
+// Process group with 1 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [0];
+    p_bnProcBufRes  = (__m256i*) &bnProcBufRes [0];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [0];
+    p_llrProcBuf256 = (__m256i*) &llrProcBuf   [0];
+    p_llrRes        = (__m256i*) &llrRes       [0];
+            for (int i=0,j=0;i<95;i++,j+=2) {
+             p_bnProcBufRes[i] = p_llrProcBuf256[i];
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j+1]);
+           ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j+1]);
+            ymmRes1 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [14592];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [14592];
+    p_llrRes        = (__m256i*) &llrRes       [14592];
+        for (int i=0,j=0;i<5;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [18432];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [15360];
+    p_llrRes        = (__m256i*) &llrRes       [15360];
+        for (int i=0,j=0;i<3;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [20736];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [15744];
+    p_llrRes        = (__m256i*) &llrRes       [15744];
+        for (int i=0,j=0;i<3;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [23424];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16128];
+    p_llrRes        = (__m256i*) &llrRes       [16128];
+        for (int i=0,j=0;i<3;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [26496];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16512];
+    p_llrRes        = (__m256i*) &llrRes       [16512];
+        for (int i=0,j=0;i<5;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [33408];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [17280];
+    p_llrRes        = (__m256i*) &llrRes       [17280];
+        for (int i=0,j=0;i<3;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 11 CNs 
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [37248];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [17664];
+    p_llrRes        = (__m256i*) &llrRes       [17664];
+            for (int i=0,j=0;i<3;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [41856];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [18048];
+    p_llrRes        = (__m256i*) &llrRes       [18048];
+        for (int i=0,j=0;i<3;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 14 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [46848];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [18432];
+    p_llrRes        = (__m256i*) &llrRes       [18432];
+        for (int i=0,j=0;i<3;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [52224];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [18816];
+    p_llrRes        = (__m256i*) &llrRes       [18816];
+        for (int i=0,j=0;i<3;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [58368];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [19200];
+    p_llrRes        = (__m256i*) &llrRes       [19200];
+            for (int i=0,j=0;i<3;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with <23 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [66816];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [19584];
+    p_llrRes        = (__m256i*) &llrRes       [19584];
+        for (int i=0,j=0;i<3;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z88_R15_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z88_R15_AVX2.c
new file mode 100644
index 0000000000..607d88744c
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z88_R15_AVX2.c
@@ -0,0 +1,757 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProcPc_BG2_Z88_R15_AVX2(int8_t* bnProcBuf, int8_t* bnProcBufRes,  int8_t* llrRes ,  int8_t* llrProcBuf ) {
+   __m256i ymm0, ymm1, ymmRes0, ymmRes1;  
+        __m128i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m128i* p_llrProcBuf;
+        __m256i* p_llrProcBuf256; 
+        __m256i* p_llrRes; 
+// Process group with 1 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [0];
+    p_bnProcBufRes  = (__m256i*) &bnProcBufRes [0];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [0];
+    p_llrProcBuf256 = (__m256i*) &llrProcBuf   [0];
+    p_llrRes        = (__m256i*) &llrRes       [0];
+            for (int i=0,j=0;i<105;i++,j+=2) {
+             p_bnProcBufRes[i] = p_llrProcBuf256[i];
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j+1]);
+           ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j+1]);
+            ymmRes1 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [14592];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [14592];
+    p_llrRes        = (__m256i*) &llrRes       [14592];
+        for (int i=0,j=0;i<6;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [18432];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [15360];
+    p_llrRes        = (__m256i*) &llrRes       [15360];
+        for (int i=0,j=0;i<3;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [20736];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [15744];
+    p_llrRes        = (__m256i*) &llrRes       [15744];
+        for (int i=0,j=0;i<3;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [23424];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16128];
+    p_llrRes        = (__m256i*) &llrRes       [16128];
+        for (int i=0,j=0;i<3;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [26496];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16512];
+    p_llrRes        = (__m256i*) &llrRes       [16512];
+        for (int i=0,j=0;i<6;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [33408];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [17280];
+    p_llrRes        = (__m256i*) &llrRes       [17280];
+        for (int i=0,j=0;i<3;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 11 CNs 
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [37248];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [17664];
+    p_llrRes        = (__m256i*) &llrRes       [17664];
+            for (int i=0,j=0;i<3;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [41856];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [18048];
+    p_llrRes        = (__m256i*) &llrRes       [18048];
+        for (int i=0,j=0;i<3;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 14 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [46848];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [18432];
+    p_llrRes        = (__m256i*) &llrRes       [18432];
+        for (int i=0,j=0;i<3;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [52224];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [18816];
+    p_llrRes        = (__m256i*) &llrRes       [18816];
+        for (int i=0,j=0;i<3;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [58368];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [19200];
+    p_llrRes        = (__m256i*) &llrRes       [19200];
+            for (int i=0,j=0;i<3;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with <23 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [66816];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [19584];
+    p_llrRes        = (__m256i*) &llrRes       [19584];
+        for (int i=0,j=0;i<3;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z8_R15_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z8_R15_AVX2.c
new file mode 100644
index 0000000000..0aa77ce254
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z8_R15_AVX2.c
@@ -0,0 +1,757 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProcPc_BG2_Z8_R15_AVX2(int8_t* bnProcBuf, int8_t* bnProcBufRes,  int8_t* llrRes ,  int8_t* llrProcBuf ) {
+   __m256i ymm0, ymm1, ymmRes0, ymmRes1;  
+        __m128i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m128i* p_llrProcBuf;
+        __m256i* p_llrProcBuf256; 
+        __m256i* p_llrRes; 
+// Process group with 1 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [0];
+    p_bnProcBufRes  = (__m256i*) &bnProcBufRes [0];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [0];
+    p_llrProcBuf256 = (__m256i*) &llrProcBuf   [0];
+    p_llrRes        = (__m256i*) &llrRes       [0];
+            for (int i=0,j=0;i<10;i++,j+=2) {
+             p_bnProcBufRes[i] = p_llrProcBuf256[i];
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j+1]);
+           ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j+1]);
+            ymmRes1 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [14592];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [14592];
+    p_llrRes        = (__m256i*) &llrRes       [14592];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [18432];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [15360];
+    p_llrRes        = (__m256i*) &llrRes       [15360];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [20736];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [15744];
+    p_llrRes        = (__m256i*) &llrRes       [15744];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [23424];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16128];
+    p_llrRes        = (__m256i*) &llrRes       [16128];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [26496];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16512];
+    p_llrRes        = (__m256i*) &llrRes       [16512];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [33408];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [17280];
+    p_llrRes        = (__m256i*) &llrRes       [17280];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 11 CNs 
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [37248];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [17664];
+    p_llrRes        = (__m256i*) &llrRes       [17664];
+            for (int i=0,j=0;i<1;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [41856];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [18048];
+    p_llrRes        = (__m256i*) &llrRes       [18048];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 14 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [46848];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [18432];
+    p_llrRes        = (__m256i*) &llrRes       [18432];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [52224];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [18816];
+    p_llrRes        = (__m256i*) &llrRes       [18816];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [58368];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [19200];
+    p_llrRes        = (__m256i*) &llrRes       [19200];
+            for (int i=0,j=0;i<1;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with <23 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [66816];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [19584];
+    p_llrRes        = (__m256i*) &llrRes       [19584];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z96_R15_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z96_R15_AVX2.c
new file mode 100644
index 0000000000..4239544706
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z96_R15_AVX2.c
@@ -0,0 +1,757 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProcPc_BG2_Z96_R15_AVX2(int8_t* bnProcBuf, int8_t* bnProcBufRes,  int8_t* llrRes ,  int8_t* llrProcBuf ) {
+   __m256i ymm0, ymm1, ymmRes0, ymmRes1;  
+        __m128i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m128i* p_llrProcBuf;
+        __m256i* p_llrProcBuf256; 
+        __m256i* p_llrRes; 
+// Process group with 1 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [0];
+    p_bnProcBufRes  = (__m256i*) &bnProcBufRes [0];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [0];
+    p_llrProcBuf256 = (__m256i*) &llrProcBuf   [0];
+    p_llrRes        = (__m256i*) &llrRes       [0];
+            for (int i=0,j=0;i<114;i++,j+=2) {
+             p_bnProcBufRes[i] = p_llrProcBuf256[i];
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j+1]);
+           ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j+1]);
+            ymmRes1 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [14592];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [14592];
+    p_llrRes        = (__m256i*) &llrRes       [14592];
+        for (int i=0,j=0;i<6;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [18432];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [15360];
+    p_llrRes        = (__m256i*) &llrRes       [15360];
+        for (int i=0,j=0;i<3;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [20736];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [15744];
+    p_llrRes        = (__m256i*) &llrRes       [15744];
+        for (int i=0,j=0;i<3;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [23424];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16128];
+    p_llrRes        = (__m256i*) &llrRes       [16128];
+        for (int i=0,j=0;i<3;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [26496];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16512];
+    p_llrRes        = (__m256i*) &llrRes       [16512];
+        for (int i=0,j=0;i<6;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [33408];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [17280];
+    p_llrRes        = (__m256i*) &llrRes       [17280];
+        for (int i=0,j=0;i<3;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 11 CNs 
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [37248];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [17664];
+    p_llrRes        = (__m256i*) &llrRes       [17664];
+            for (int i=0,j=0;i<3;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [41856];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [18048];
+    p_llrRes        = (__m256i*) &llrRes       [18048];
+        for (int i=0,j=0;i<3;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 14 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [46848];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [18432];
+    p_llrRes        = (__m256i*) &llrRes       [18432];
+        for (int i=0,j=0;i<3;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [52224];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [18816];
+    p_llrRes        = (__m256i*) &llrRes       [18816];
+        for (int i=0,j=0;i<3;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [58368];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [19200];
+    p_llrRes        = (__m256i*) &llrRes       [19200];
+            for (int i=0,j=0;i<3;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with <23 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [66816];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [19584];
+    p_llrRes        = (__m256i*) &llrRes       [19584];
+        for (int i=0,j=0;i<3;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z9_R15_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z9_R15_AVX2.c
new file mode 100644
index 0000000000..5c085b51c2
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/bnProcPc/nrLDPC_bnProcPc_BG2_Z9_R15_AVX2.c
@@ -0,0 +1,757 @@
+#include <stdint.h>
+#include <immintrin.h>
+void nrLDPC_bnProcPc_BG2_Z9_R15_AVX2(int8_t* bnProcBuf, int8_t* bnProcBufRes,  int8_t* llrRes ,  int8_t* llrProcBuf ) {
+   __m256i ymm0, ymm1, ymmRes0, ymmRes1;  
+        __m128i* p_bnProcBuf; 
+        __m256i* p_bnProcBufRes; 
+        __m128i* p_llrProcBuf;
+        __m256i* p_llrProcBuf256; 
+        __m256i* p_llrRes; 
+// Process group with 1 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [0];
+    p_bnProcBufRes  = (__m256i*) &bnProcBufRes [0];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [0];
+    p_llrProcBuf256 = (__m256i*) &llrProcBuf   [0];
+    p_llrRes        = (__m256i*) &llrRes       [0];
+            for (int i=0,j=0;i<11;i++,j+=2) {
+             p_bnProcBufRes[i] = p_llrProcBuf256[i];
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j+1]);
+           ymm1 = _mm256_cvtepi8_epi16(p_llrProcBuf[j+1]);
+            ymmRes1 = _mm256_adds_epi16(ymm0, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 2 CNs 
+// Process group with 3 CNs 
+// Process group with 4 CNs 
+// Process group with 5 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [14592];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [14592];
+    p_llrRes        = (__m256i*) &llrRes       [14592];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 6 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [18432];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [15360];
+    p_llrRes        = (__m256i*) &llrRes       [15360];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 7 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [20736];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [15744];
+    p_llrRes        = (__m256i*) &llrRes       [15744];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 8 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [23424];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16128];
+    p_llrRes        = (__m256i*) &llrRes       [16128];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 9 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [26496];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [16512];
+    p_llrRes        = (__m256i*) &llrRes       [16512];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 10 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [33408];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [17280];
+    p_llrRes        = (__m256i*) &llrRes       [17280];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 11 CNs 
+// Process group with 12 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [37248];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [17664];
+    p_llrRes        = (__m256i*) &llrRes       [17664];
+            for (int i=0,j=0;i<1;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 13 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [41856];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [18048];
+    p_llrRes        = (__m256i*) &llrRes       [18048];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 14 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [46848];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [18432];
+    p_llrRes        = (__m256i*) &llrRes       [18432];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 15 CNs 
+// Process group with 16 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [52224];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [18816];
+    p_llrRes        = (__m256i*) &llrRes       [18816];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+       ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 17 CNs 
+// Process group with 18 CNs 
+// Process group with 19 CNs 
+// Process group with 20 CNs 
+// Process group with 21 CNs 
+// Process group with 22 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [58368];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [19200];
+    p_llrRes        = (__m256i*) &llrRes       [19200];
+            for (int i=0,j=0;i<1;i++,j+=2) {
+            ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+            ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+           ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+            ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+            ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+            ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+            ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+            ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with <23 CNs 
+    p_bnProcBuf     = (__m128i*) &bnProcBuf    [66816];
+    p_llrProcBuf    = (__m128i*) &llrProcBuf   [19584];
+    p_llrRes        = (__m256i*) &llrRes       [19584];
+        for (int i=0,j=0;i<1;i++,j+=2) {
+        ymmRes0 = _mm256_cvtepi8_epi16(p_bnProcBuf [j]);
+        ymmRes1 = _mm256_cvtepi8_epi16(p_bnProcBuf [j +1]);
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[24 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[48 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[72 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[96 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[120 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[144 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[168 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[192 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[216 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[240 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[264 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[288 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[312 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[336 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[360 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[384 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[408 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[432 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[456 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[480 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[504 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1 = _mm256_cvtepi8_epi16(p_bnProcBuf[528 + j +1]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1); 
+        ymm0    = _mm256_cvtepi8_epi16(p_llrProcBuf[j]);
+        ymmRes0 = _mm256_adds_epi16(ymmRes0, ymm0);
+        ymm1    = _mm256_cvtepi8_epi16(p_llrProcBuf[j +1 ]);
+        ymmRes1 = _mm256_adds_epi16(ymmRes1, ymm1);
+        ymm0 = _mm256_packs_epi16(ymmRes0, ymmRes1);
+            *p_llrRes = _mm256_permute4x64_epi64(ymm0, 0xD8);
+             p_llrRes++;
+}
+// Process group with 24 CNs 
+// Process group with 25 CNs 
+// Process group with 26 CNs 
+// Process group with 27 CNs 
+// Process group with 28 CNs 
+// Process group with 29 CNs 
+// Process group with 30 CNs 
+}
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z104_13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG1_Z104_R13_AVX2.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z104_13_AVX2.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG1_Z104_R13_AVX2.c
index 95446dd402..ee97fc62bf 100644
--- a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z104_13_AVX2.c
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG1_Z104_R13_AVX2.c
@@ -1,6 +1,6 @@
 #include <stdint.h>
 #include <immintrin.h>
-void nrLDPC_cnProc_BG1_Z104_13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG1_Z104_R13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m256i ymm0, min, sgn,ones,maxLLR;
                 ones   = _mm256_set1_epi8((char)1);
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/cnProc/nrLDPC_cnProc_BG1_Z10_R13_AVX2.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z9_13_AVX2.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG1_Z10_R13_AVX2.c
index 0e1766e781..311cecf323 100644
--- 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/cnProc/nrLDPC_cnProc_BG1_Z10_R13_AVX2.c
@@ -1,6 +1,6 @@
 #include <stdint.h>
 #include <immintrin.h>
-void nrLDPC_cnProc_BG1_Z9_13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG1_Z10_R13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m256i ymm0, min, sgn,ones,maxLLR;
                 ones   = _mm256_set1_epi8((char)1);
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/cnProc/nrLDPC_cnProc_BG1_Z112_R13_AVX2.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z112_13_AVX2.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG1_Z112_R13_AVX2.c
index 79054a0e63..c2485cf538 100644
--- 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/cnProc/nrLDPC_cnProc_BG1_Z112_R13_AVX2.c
@@ -1,6 +1,6 @@
 #include <stdint.h>
 #include <immintrin.h>
-void nrLDPC_cnProc_BG1_Z112_13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG1_Z112_R13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m256i ymm0, min, sgn,ones,maxLLR;
                 ones   = _mm256_set1_epi8((char)1);
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/cnProc/nrLDPC_cnProc_BG1_Z11_R13_AVX2.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z11_13_AVX2.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG1_Z11_R13_AVX2.c
index f7153df62e..c923dfd293 100644
--- 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/cnProc/nrLDPC_cnProc_BG1_Z11_R13_AVX2.c
@@ -1,6 +1,6 @@
 #include <stdint.h>
 #include <immintrin.h>
-void nrLDPC_cnProc_BG1_Z11_13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG1_Z11_R13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m256i ymm0, min, sgn,ones,maxLLR;
                 ones   = _mm256_set1_epi8((char)1);
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/cnProc/nrLDPC_cnProc_BG1_Z120_R13_AVX2.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z120_13_AVX2.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG1_Z120_R13_AVX2.c
index eb32ce0f1e..f3c06abb67 100644
--- 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/cnProc/nrLDPC_cnProc_BG1_Z120_R13_AVX2.c
@@ -1,6 +1,6 @@
 #include <stdint.h>
 #include <immintrin.h>
-void nrLDPC_cnProc_BG1_Z120_13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG1_Z120_R13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m256i ymm0, min, sgn,ones,maxLLR;
                 ones   = _mm256_set1_epi8((char)1);
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/cnProc/nrLDPC_cnProc_BG1_Z128_R13_AVX2.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z128_13_AVX2.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG1_Z128_R13_AVX2.c
index a44948351f..3388c1c95b 100644
--- 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/cnProc/nrLDPC_cnProc_BG1_Z128_R13_AVX2.c
@@ -1,6 +1,6 @@
 #include <stdint.h>
 #include <immintrin.h>
-void nrLDPC_cnProc_BG1_Z128_13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG1_Z128_R13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m256i ymm0, min, sgn,ones,maxLLR;
                 ones   = _mm256_set1_epi8((char)1);
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/cnProc/nrLDPC_cnProc_BG1_Z12_R13_AVX2.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z12_13_AVX2.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG1_Z12_R13_AVX2.c
index 76870c1b62..1103606382 100644
--- 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/cnProc/nrLDPC_cnProc_BG1_Z12_R13_AVX2.c
@@ -1,6 +1,6 @@
 #include <stdint.h>
 #include <immintrin.h>
-void nrLDPC_cnProc_BG1_Z12_13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG1_Z12_R13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m256i ymm0, min, sgn,ones,maxLLR;
                 ones   = _mm256_set1_epi8((char)1);
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/cnProc/nrLDPC_cnProc_BG1_Z13_R13_AVX2.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z14_13_AVX2.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG1_Z13_R13_AVX2.c
index 05981134d1..6a3b0ee573 100644
--- 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/cnProc/nrLDPC_cnProc_BG1_Z13_R13_AVX2.c
@@ -1,6 +1,6 @@
 #include <stdint.h>
 #include <immintrin.h>
-void nrLDPC_cnProc_BG1_Z14_13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG1_Z13_R13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m256i ymm0, min, sgn,ones,maxLLR;
                 ones   = _mm256_set1_epi8((char)1);
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/cnProc/nrLDPC_cnProc_BG1_Z144_R13_AVX2.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z144_13_AVX2.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG1_Z144_R13_AVX2.c
index 149302bef4..8cb5cade6e 100644
--- 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/cnProc/nrLDPC_cnProc_BG1_Z144_R13_AVX2.c
@@ -1,6 +1,6 @@
 #include <stdint.h>
 #include <immintrin.h>
-void nrLDPC_cnProc_BG1_Z144_13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG1_Z144_R13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m256i ymm0, min, sgn,ones,maxLLR;
                 ones   = _mm256_set1_epi8((char)1);
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/cnProc/nrLDPC_cnProc_BG1_Z14_R13_AVX2.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z13_13_AVX2.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG1_Z14_R13_AVX2.c
index ec3daecbbb..44ee09d03d 100644
--- 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/cnProc/nrLDPC_cnProc_BG1_Z14_R13_AVX2.c
@@ -1,6 +1,6 @@
 #include <stdint.h>
 #include <immintrin.h>
-void nrLDPC_cnProc_BG1_Z13_13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG1_Z14_R13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m256i ymm0, min, sgn,ones,maxLLR;
                 ones   = _mm256_set1_epi8((char)1);
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/cnProc/nrLDPC_cnProc_BG1_Z15_R13_AVX2.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z15_13_AVX2.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG1_Z15_R13_AVX2.c
index 56c6ecfbc8..ffc71426b7 100644
--- 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/cnProc/nrLDPC_cnProc_BG1_Z15_R13_AVX2.c
@@ -1,6 +1,6 @@
 #include <stdint.h>
 #include <immintrin.h>
-void nrLDPC_cnProc_BG1_Z15_13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG1_Z15_R13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m256i ymm0, min, sgn,ones,maxLLR;
                 ones   = _mm256_set1_epi8((char)1);
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/cnProc/nrLDPC_cnProc_BG1_Z160_R13_AVX2.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z160_13_AVX2.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG1_Z160_R13_AVX2.c
index c3cc47be33..a5248e2c11 100644
--- 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/cnProc/nrLDPC_cnProc_BG1_Z160_R13_AVX2.c
@@ -1,6 +1,6 @@
 #include <stdint.h>
 #include <immintrin.h>
-void nrLDPC_cnProc_BG1_Z160_13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG1_Z160_R13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m256i ymm0, min, sgn,ones,maxLLR;
                 ones   = _mm256_set1_epi8((char)1);
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/cnProc/nrLDPC_cnProc_BG1_Z16_R13_AVX2.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z16_13_AVX2.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG1_Z16_R13_AVX2.c
index 294892c402..5067a4d568 100644
--- 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/cnProc/nrLDPC_cnProc_BG1_Z16_R13_AVX2.c
@@ -1,6 +1,6 @@
 #include <stdint.h>
 #include <immintrin.h>
-void nrLDPC_cnProc_BG1_Z16_13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG1_Z16_R13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m256i ymm0, min, sgn,ones,maxLLR;
                 ones   = _mm256_set1_epi8((char)1);
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/cnProc/nrLDPC_cnProc_BG1_Z176_R13_AVX2.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z176_13_AVX2.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG1_Z176_R13_AVX2.c
index b2a243f793..ae640b1fd4 100644
--- 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/cnProc/nrLDPC_cnProc_BG1_Z176_R13_AVX2.c
@@ -1,6 +1,6 @@
 #include <stdint.h>
 #include <immintrin.h>
-void nrLDPC_cnProc_BG1_Z176_13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG1_Z176_R13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m256i ymm0, min, sgn,ones,maxLLR;
                 ones   = _mm256_set1_epi8((char)1);
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/cnProc/nrLDPC_cnProc_BG1_Z18_R13_AVX2.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z18_13_AVX2.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG1_Z18_R13_AVX2.c
index b4c01b1337..56cd28a9ef 100644
--- 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/cnProc/nrLDPC_cnProc_BG1_Z18_R13_AVX2.c
@@ -1,6 +1,6 @@
 #include <stdint.h>
 #include <immintrin.h>
-void nrLDPC_cnProc_BG1_Z18_13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG1_Z18_R13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m256i ymm0, min, sgn,ones,maxLLR;
                 ones   = _mm256_set1_epi8((char)1);
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/cnProc/nrLDPC_cnProc_BG1_Z192_R13_AVX2.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z192_13_AVX2.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG1_Z192_R13_AVX2.c
index 983a94b5c0..e298ade2d5 100644
--- 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/cnProc/nrLDPC_cnProc_BG1_Z192_R13_AVX2.c
@@ -1,6 +1,6 @@
 #include <stdint.h>
 #include <immintrin.h>
-void nrLDPC_cnProc_BG1_Z192_13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG1_Z192_R13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m256i ymm0, min, sgn,ones,maxLLR;
                 ones   = _mm256_set1_epi8((char)1);
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/cnProc/nrLDPC_cnProc_BG1_Z208_R13_AVX2.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z208_13_AVX2.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG1_Z208_R13_AVX2.c
index 65da8e4e6b..c2f0497934 100644
--- 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/cnProc/nrLDPC_cnProc_BG1_Z208_R13_AVX2.c
@@ -1,6 +1,6 @@
 #include <stdint.h>
 #include <immintrin.h>
-void nrLDPC_cnProc_BG1_Z208_13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG1_Z208_R13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m256i ymm0, min, sgn,ones,maxLLR;
                 ones   = _mm256_set1_epi8((char)1);
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/cnProc/nrLDPC_cnProc_BG1_Z20_R13_AVX2.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z20_13_AVX2.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG1_Z20_R13_AVX2.c
index 524b308c1a..75567e0c0b 100644
--- 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/cnProc/nrLDPC_cnProc_BG1_Z20_R13_AVX2.c
@@ -1,6 +1,6 @@
 #include <stdint.h>
 #include <immintrin.h>
-void nrLDPC_cnProc_BG1_Z20_13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG1_Z20_R13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m256i ymm0, min, sgn,ones,maxLLR;
                 ones   = _mm256_set1_epi8((char)1);
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/cnProc/nrLDPC_cnProc_BG1_Z224_R13_AVX2.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z224_13_AVX2.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG1_Z224_R13_AVX2.c
index 0f78d0f39b..49fd55bf02 100644
--- 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/cnProc/nrLDPC_cnProc_BG1_Z224_R13_AVX2.c
@@ -1,6 +1,6 @@
 #include <stdint.h>
 #include <immintrin.h>
-void nrLDPC_cnProc_BG1_Z224_13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG1_Z224_R13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m256i ymm0, min, sgn,ones,maxLLR;
                 ones   = _mm256_set1_epi8((char)1);
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/cnProc/nrLDPC_cnProc_BG1_Z22_R13_AVX2.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z22_13_AVX2.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG1_Z22_R13_AVX2.c
index 230f5acc7d..a2a5cde850 100644
--- 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/cnProc/nrLDPC_cnProc_BG1_Z22_R13_AVX2.c
@@ -1,6 +1,6 @@
 #include <stdint.h>
 #include <immintrin.h>
-void nrLDPC_cnProc_BG1_Z22_13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG1_Z22_R13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m256i ymm0, min, sgn,ones,maxLLR;
                 ones   = _mm256_set1_epi8((char)1);
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/cnProc/nrLDPC_cnProc_BG1_Z240_R13_AVX2.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z240_13_AVX2.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG1_Z240_R13_AVX2.c
index 05944f1e0f..1b3cc7c6ad 100644
--- 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/cnProc/nrLDPC_cnProc_BG1_Z240_R13_AVX2.c
@@ -1,6 +1,6 @@
 #include <stdint.h>
 #include <immintrin.h>
-void nrLDPC_cnProc_BG1_Z240_13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG1_Z240_R13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m256i ymm0, min, sgn,ones,maxLLR;
                 ones   = _mm256_set1_epi8((char)1);
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/cnProc/nrLDPC_cnProc_BG1_Z24_R13_AVX2.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z24_13_AVX2.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG1_Z24_R13_AVX2.c
index f2881a8790..f719ff19e2 100644
--- 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/cnProc/nrLDPC_cnProc_BG1_Z24_R13_AVX2.c
@@ -1,6 +1,6 @@
 #include <stdint.h>
 #include <immintrin.h>
-void nrLDPC_cnProc_BG1_Z24_13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG1_Z24_R13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m256i ymm0, min, sgn,ones,maxLLR;
                 ones   = _mm256_set1_epi8((char)1);
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/cnProc/nrLDPC_cnProc_BG1_Z256_R13_AVX2.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z256_13_AVX2.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG1_Z256_R13_AVX2.c
index 833387428e..230f9e07a3 100644
--- 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/cnProc/nrLDPC_cnProc_BG1_Z256_R13_AVX2.c
@@ -1,6 +1,6 @@
 #include <stdint.h>
 #include <immintrin.h>
-void nrLDPC_cnProc_BG1_Z256_13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG1_Z256_R13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m256i ymm0, min, sgn,ones,maxLLR;
                 ones   = _mm256_set1_epi8((char)1);
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/cnProc/nrLDPC_cnProc_BG1_Z26_R13_AVX2.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z26_13_AVX2.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG1_Z26_R13_AVX2.c
index cce7e248a6..94a7f0c389 100644
--- 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/cnProc/nrLDPC_cnProc_BG1_Z26_R13_AVX2.c
@@ -1,6 +1,6 @@
 #include <stdint.h>
 #include <immintrin.h>
-void nrLDPC_cnProc_BG1_Z26_13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG1_Z26_R13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m256i ymm0, min, sgn,ones,maxLLR;
                 ones   = _mm256_set1_epi8((char)1);
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/cnProc/nrLDPC_cnProc_BG1_Z288_R13_AVX2.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z288_13_AVX2.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG1_Z288_R13_AVX2.c
index 54684bf1a7..91066132a4 100644
--- 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/cnProc/nrLDPC_cnProc_BG1_Z288_R13_AVX2.c
@@ -1,6 +1,6 @@
 #include <stdint.h>
 #include <immintrin.h>
-void nrLDPC_cnProc_BG1_Z288_13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG1_Z288_R13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m256i ymm0, min, sgn,ones,maxLLR;
                 ones   = _mm256_set1_epi8((char)1);
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/cnProc/nrLDPC_cnProc_BG1_Z28_R13_AVX2.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z28_13_AVX2.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG1_Z28_R13_AVX2.c
index a7db0b74f4..568c0096f7 100644
--- 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/cnProc/nrLDPC_cnProc_BG1_Z28_R13_AVX2.c
@@ -1,6 +1,6 @@
 #include <stdint.h>
 #include <immintrin.h>
-void nrLDPC_cnProc_BG1_Z28_13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG1_Z28_R13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m256i ymm0, min, sgn,ones,maxLLR;
                 ones   = _mm256_set1_epi8((char)1);
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/cnProc/nrLDPC_cnProc_BG1_Z2_R13_AVX2.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z2_13_AVX2.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG1_Z2_R13_AVX2.c
index 3d0a7276c6..e91d0d360e 100644
--- 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/cnProc/nrLDPC_cnProc_BG1_Z2_R13_AVX2.c
@@ -1,6 +1,6 @@
 #include <stdint.h>
 #include <immintrin.h>
-void nrLDPC_cnProc_BG1_Z2_13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG1_Z2_R13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m256i ymm0, min, sgn,ones,maxLLR;
                 ones   = _mm256_set1_epi8((char)1);
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/cnProc/nrLDPC_cnProc_BG1_Z30_R13_AVX2.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z30_13_AVX2.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG1_Z30_R13_AVX2.c
index bd4d801c78..465d36db41 100644
--- 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/cnProc/nrLDPC_cnProc_BG1_Z30_R13_AVX2.c
@@ -1,6 +1,6 @@
 #include <stdint.h>
 #include <immintrin.h>
-void nrLDPC_cnProc_BG1_Z30_13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG1_Z30_R13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m256i ymm0, min, sgn,ones,maxLLR;
                 ones   = _mm256_set1_epi8((char)1);
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/cnProc/nrLDPC_cnProc_BG1_Z320_R13_AVX2.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z320_13_AVX2.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG1_Z320_R13_AVX2.c
index 1770d7d3cf..99f8891c54 100644
--- 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/cnProc/nrLDPC_cnProc_BG1_Z320_R13_AVX2.c
@@ -1,6 +1,6 @@
 #include <stdint.h>
 #include <immintrin.h>
-void nrLDPC_cnProc_BG1_Z320_13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG1_Z320_R13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m256i ymm0, min, sgn,ones,maxLLR;
                 ones   = _mm256_set1_epi8((char)1);
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/cnProc/nrLDPC_cnProc_BG1_Z32_R13_AVX2.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z32_13_AVX2.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG1_Z32_R13_AVX2.c
index 29d09b8af6..5baaadd512 100644
--- 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/cnProc/nrLDPC_cnProc_BG1_Z32_R13_AVX2.c
@@ -1,6 +1,6 @@
 #include <stdint.h>
 #include <immintrin.h>
-void nrLDPC_cnProc_BG1_Z32_13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG1_Z32_R13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m256i ymm0, min, sgn,ones,maxLLR;
                 ones   = _mm256_set1_epi8((char)1);
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/cnProc/nrLDPC_cnProc_BG1_Z352_R13_AVX2.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z352_13_AVX2.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG1_Z352_R13_AVX2.c
index 99f34e7d1c..fb4a93a98e 100644
--- 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/cnProc/nrLDPC_cnProc_BG1_Z352_R13_AVX2.c
@@ -1,6 +1,6 @@
 #include <stdint.h>
 #include <immintrin.h>
-void nrLDPC_cnProc_BG1_Z352_13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG1_Z352_R13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m256i ymm0, min, sgn,ones,maxLLR;
                 ones   = _mm256_set1_epi8((char)1);
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/cnProc/nrLDPC_cnProc_BG1_Z36_R13_AVX2.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z36_13_AVX2.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG1_Z36_R13_AVX2.c
index 7ca983828d..be11649a57 100644
--- 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/cnProc/nrLDPC_cnProc_BG1_Z36_R13_AVX2.c
@@ -1,6 +1,6 @@
 #include <stdint.h>
 #include <immintrin.h>
-void nrLDPC_cnProc_BG1_Z36_13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG1_Z36_R13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m256i ymm0, min, sgn,ones,maxLLR;
                 ones   = _mm256_set1_epi8((char)1);
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/cnProc/nrLDPC_cnProc_BG1_Z384_R13_AVX2.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z384_13_AVX2.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG1_Z384_R13_AVX2.c
index 4acaf3f656..cb67f5031d 100644
--- 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/cnProc/nrLDPC_cnProc_BG1_Z384_R13_AVX2.c
@@ -1,6 +1,6 @@
 #include <stdint.h>
 #include <immintrin.h>
-void nrLDPC_cnProc_BG1_Z384_13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG1_Z384_R13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m256i ymm0, min, sgn,ones,maxLLR;
                 ones   = _mm256_set1_epi8((char)1);
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/cnProc/nrLDPC_cnProc_BG1_Z3_R13_AVX2.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z3_13_AVX2.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG1_Z3_R13_AVX2.c
index 8083808f29..a383a80b03 100644
--- 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/cnProc/nrLDPC_cnProc_BG1_Z3_R13_AVX2.c
@@ -1,6 +1,6 @@
 #include <stdint.h>
 #include <immintrin.h>
-void nrLDPC_cnProc_BG1_Z3_13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG1_Z3_R13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m256i ymm0, min, sgn,ones,maxLLR;
                 ones   = _mm256_set1_epi8((char)1);
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/cnProc/nrLDPC_cnProc_BG1_Z40_R13_AVX2.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z40_13_AVX2.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG1_Z40_R13_AVX2.c
index dff643e9eb..ce37578a66 100644
--- 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/cnProc/nrLDPC_cnProc_BG1_Z40_R13_AVX2.c
@@ -1,6 +1,6 @@
 #include <stdint.h>
 #include <immintrin.h>
-void nrLDPC_cnProc_BG1_Z40_13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG1_Z40_R13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m256i ymm0, min, sgn,ones,maxLLR;
                 ones   = _mm256_set1_epi8((char)1);
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/cnProc/nrLDPC_cnProc_BG1_Z44_R13_AVX2.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z44_13_AVX2.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG1_Z44_R13_AVX2.c
index 0f6a28ab52..4d7e77ed7b 100644
--- 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/cnProc/nrLDPC_cnProc_BG1_Z44_R13_AVX2.c
@@ -1,6 +1,6 @@
 #include <stdint.h>
 #include <immintrin.h>
-void nrLDPC_cnProc_BG1_Z44_13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG1_Z44_R13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m256i ymm0, min, sgn,ones,maxLLR;
                 ones   = _mm256_set1_epi8((char)1);
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/cnProc/nrLDPC_cnProc_BG1_Z48_R13_AVX2.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z48_13_AVX2.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG1_Z48_R13_AVX2.c
index eb5ead281d..6ed9fbb101 100644
--- 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/cnProc/nrLDPC_cnProc_BG1_Z48_R13_AVX2.c
@@ -1,6 +1,6 @@
 #include <stdint.h>
 #include <immintrin.h>
-void nrLDPC_cnProc_BG1_Z48_13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG1_Z48_R13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m256i ymm0, min, sgn,ones,maxLLR;
                 ones   = _mm256_set1_epi8((char)1);
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/cnProc/nrLDPC_cnProc_BG1_Z4_R13_AVX2.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z4_13_AVX2.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG1_Z4_R13_AVX2.c
index 1bae753666..863ff40747 100644
--- 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/cnProc/nrLDPC_cnProc_BG1_Z4_R13_AVX2.c
@@ -1,6 +1,6 @@
 #include <stdint.h>
 #include <immintrin.h>
-void nrLDPC_cnProc_BG1_Z4_13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG1_Z4_R13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m256i ymm0, min, sgn,ones,maxLLR;
                 ones   = _mm256_set1_epi8((char)1);
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/cnProc/nrLDPC_cnProc_BG1_Z52_R13_AVX2.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z52_13_AVX2.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG1_Z52_R13_AVX2.c
index 94ad129f3a..dbd111868a 100644
--- 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/cnProc/nrLDPC_cnProc_BG1_Z52_R13_AVX2.c
@@ -1,6 +1,6 @@
 #include <stdint.h>
 #include <immintrin.h>
-void nrLDPC_cnProc_BG1_Z52_13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG1_Z52_R13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m256i ymm0, min, sgn,ones,maxLLR;
                 ones   = _mm256_set1_epi8((char)1);
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/cnProc/nrLDPC_cnProc_BG1_Z56_R13_AVX2.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z56_13_AVX2.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG1_Z56_R13_AVX2.c
index 7d07229100..5469b77812 100644
--- 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/cnProc/nrLDPC_cnProc_BG1_Z56_R13_AVX2.c
@@ -1,6 +1,6 @@
 #include <stdint.h>
 #include <immintrin.h>
-void nrLDPC_cnProc_BG1_Z56_13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG1_Z56_R13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m256i ymm0, min, sgn,ones,maxLLR;
                 ones   = _mm256_set1_epi8((char)1);
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/cnProc/nrLDPC_cnProc_BG1_Z5_R13_AVX2.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z5_13_AVX2.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG1_Z5_R13_AVX2.c
index 54581a98dc..493706b9ad 100644
--- 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/cnProc/nrLDPC_cnProc_BG1_Z5_R13_AVX2.c
@@ -1,6 +1,6 @@
 #include <stdint.h>
 #include <immintrin.h>
-void nrLDPC_cnProc_BG1_Z5_13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG1_Z5_R13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m256i ymm0, min, sgn,ones,maxLLR;
                 ones   = _mm256_set1_epi8((char)1);
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/cnProc/nrLDPC_cnProc_BG1_Z60_R13_AVX2.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z60_13_AVX2.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG1_Z60_R13_AVX2.c
index e4d29f71f7..b504267826 100644
--- 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/cnProc/nrLDPC_cnProc_BG1_Z60_R13_AVX2.c
@@ -1,6 +1,6 @@
 #include <stdint.h>
 #include <immintrin.h>
-void nrLDPC_cnProc_BG1_Z60_13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG1_Z60_R13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m256i ymm0, min, sgn,ones,maxLLR;
                 ones   = _mm256_set1_epi8((char)1);
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/cnProc/nrLDPC_cnProc_BG1_Z64_R13_AVX2.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z64_13_AVX2.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG1_Z64_R13_AVX2.c
index b16ae99d91..8bfb98c9ba 100644
--- 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/cnProc/nrLDPC_cnProc_BG1_Z64_R13_AVX2.c
@@ -1,6 +1,6 @@
 #include <stdint.h>
 #include <immintrin.h>
-void nrLDPC_cnProc_BG1_Z64_13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG1_Z64_R13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m256i ymm0, min, sgn,ones,maxLLR;
                 ones   = _mm256_set1_epi8((char)1);
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/cnProc/nrLDPC_cnProc_BG1_Z6_R13_AVX2.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z6_13_AVX2.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG1_Z6_R13_AVX2.c
index 8e1ee65966..7156db357e 100644
--- 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/cnProc/nrLDPC_cnProc_BG1_Z6_R13_AVX2.c
@@ -1,6 +1,6 @@
 #include <stdint.h>
 #include <immintrin.h>
-void nrLDPC_cnProc_BG1_Z6_13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG1_Z6_R13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m256i ymm0, min, sgn,ones,maxLLR;
                 ones   = _mm256_set1_epi8((char)1);
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/cnProc/nrLDPC_cnProc_BG1_Z72_R13_AVX2.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z72_13_AVX2.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG1_Z72_R13_AVX2.c
index 85186c29b8..f93ae981f8 100644
--- 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/cnProc/nrLDPC_cnProc_BG1_Z72_R13_AVX2.c
@@ -1,6 +1,6 @@
 #include <stdint.h>
 #include <immintrin.h>
-void nrLDPC_cnProc_BG1_Z72_13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG1_Z72_R13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m256i ymm0, min, sgn,ones,maxLLR;
                 ones   = _mm256_set1_epi8((char)1);
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/cnProc/nrLDPC_cnProc_BG1_Z7_R13_AVX2.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z7_13_AVX2.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG1_Z7_R13_AVX2.c
index 4ad132a2b5..fe2b974170 100644
--- 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/cnProc/nrLDPC_cnProc_BG1_Z7_R13_AVX2.c
@@ -1,6 +1,6 @@
 #include <stdint.h>
 #include <immintrin.h>
-void nrLDPC_cnProc_BG1_Z7_13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG1_Z7_R13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m256i ymm0, min, sgn,ones,maxLLR;
                 ones   = _mm256_set1_epi8((char)1);
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/cnProc/nrLDPC_cnProc_BG1_Z80_R13_AVX2.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z80_13_AVX2.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG1_Z80_R13_AVX2.c
index 3c5cdeb759..0d8db50071 100644
--- 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/cnProc/nrLDPC_cnProc_BG1_Z80_R13_AVX2.c
@@ -1,6 +1,6 @@
 #include <stdint.h>
 #include <immintrin.h>
-void nrLDPC_cnProc_BG1_Z80_13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG1_Z80_R13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m256i ymm0, min, sgn,ones,maxLLR;
                 ones   = _mm256_set1_epi8((char)1);
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/cnProc/nrLDPC_cnProc_BG1_Z88_R13_AVX2.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z88_13_AVX2.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG1_Z88_R13_AVX2.c
index 2f2b97f37f..7c7ce39c1c 100644
--- 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/cnProc/nrLDPC_cnProc_BG1_Z88_R13_AVX2.c
@@ -1,6 +1,6 @@
 #include <stdint.h>
 #include <immintrin.h>
-void nrLDPC_cnProc_BG1_Z88_13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG1_Z88_R13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m256i ymm0, min, sgn,ones,maxLLR;
                 ones   = _mm256_set1_epi8((char)1);
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/cnProc/nrLDPC_cnProc_BG1_Z8_R13_AVX2.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z8_13_AVX2.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG1_Z8_R13_AVX2.c
index c0c3612c34..8cbc7c3012 100644
--- 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/cnProc/nrLDPC_cnProc_BG1_Z8_R13_AVX2.c
@@ -1,6 +1,6 @@
 #include <stdint.h>
 #include <immintrin.h>
-void nrLDPC_cnProc_BG1_Z8_13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG1_Z8_R13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m256i ymm0, min, sgn,ones,maxLLR;
                 ones   = _mm256_set1_epi8((char)1);
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/cnProc/nrLDPC_cnProc_BG1_Z96_R13_AVX2.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z96_13_AVX2.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG1_Z96_R13_AVX2.c
index 7f6f74ff38..cae1179897 100644
--- 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/cnProc/nrLDPC_cnProc_BG1_Z96_R13_AVX2.c
@@ -1,6 +1,6 @@
 #include <stdint.h>
 #include <immintrin.h>
-void nrLDPC_cnProc_BG1_Z96_13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG1_Z96_R13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m256i ymm0, min, sgn,ones,maxLLR;
                 ones   = _mm256_set1_epi8((char)1);
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/cnProc/nrLDPC_cnProc_BG1_Z9_R13_AVX2.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z10_13_AVX2.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG1_Z9_R13_AVX2.c
index c274d4ae41..f31cf8b56a 100644
--- 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/cnProc/nrLDPC_cnProc_BG1_Z9_R13_AVX2.c
@@ -1,6 +1,6 @@
 #include <stdint.h>
 #include <immintrin.h>
-void nrLDPC_cnProc_BG1_Z10_13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG1_Z9_R13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m256i ymm0, min, sgn,ones,maxLLR;
                 ones   = _mm256_set1_epi8((char)1);
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z104_15_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z104_R15_AVX2.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z104_15_AVX2.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z104_R15_AVX2.c
index 4f65e090df..566759ac38 100644
--- a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z104_15_AVX2.c
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z104_R15_AVX2.c
@@ -1,6 +1,6 @@
 #include <stdint.h>
 #include <immintrin.h>
-void nrLDPC_cnProc_BG2_Z104_15_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG2_Z104_R15_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m256i ymm0, min, sgn,ones,maxLLR;
                 ones   = _mm256_set1_epi8((char)1);
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z10_15_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z10_R15_AVX2.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z10_15_AVX2.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z10_R15_AVX2.c
index 15034e117f..273ef7894e 100644
--- a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z10_15_AVX2.c
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z10_R15_AVX2.c
@@ -1,6 +1,6 @@
 #include <stdint.h>
 #include <immintrin.h>
-void nrLDPC_cnProc_BG2_Z10_15_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG2_Z10_R15_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m256i ymm0, min, sgn,ones,maxLLR;
                 ones   = _mm256_set1_epi8((char)1);
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z112_15_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z112_R15_AVX2.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z112_15_AVX2.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z112_R15_AVX2.c
index bfd31c4f3e..7ce92630e9 100644
--- a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z112_15_AVX2.c
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z112_R15_AVX2.c
@@ -1,6 +1,6 @@
 #include <stdint.h>
 #include <immintrin.h>
-void nrLDPC_cnProc_BG2_Z112_15_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG2_Z112_R15_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m256i ymm0, min, sgn,ones,maxLLR;
                 ones   = _mm256_set1_epi8((char)1);
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z11_15_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z11_R15_AVX2.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z11_15_AVX2.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z11_R15_AVX2.c
index 62de036c44..c7d863559a 100644
--- a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z11_15_AVX2.c
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z11_R15_AVX2.c
@@ -1,6 +1,6 @@
 #include <stdint.h>
 #include <immintrin.h>
-void nrLDPC_cnProc_BG2_Z11_15_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG2_Z11_R15_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m256i ymm0, min, sgn,ones,maxLLR;
                 ones   = _mm256_set1_epi8((char)1);
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z120_15_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z120_R15_AVX2.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z120_15_AVX2.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z120_R15_AVX2.c
index 8a70d89a99..2dfd13bfac 100644
--- a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z120_15_AVX2.c
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z120_R15_AVX2.c
@@ -1,6 +1,6 @@
 #include <stdint.h>
 #include <immintrin.h>
-void nrLDPC_cnProc_BG2_Z120_15_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG2_Z120_R15_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m256i ymm0, min, sgn,ones,maxLLR;
                 ones   = _mm256_set1_epi8((char)1);
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z128_15_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z128_R15_AVX2.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z128_15_AVX2.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z128_R15_AVX2.c
index c774057310..055e83b970 100644
--- a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z128_15_AVX2.c
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z128_R15_AVX2.c
@@ -1,6 +1,6 @@
 #include <stdint.h>
 #include <immintrin.h>
-void nrLDPC_cnProc_BG2_Z128_15_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG2_Z128_R15_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m256i ymm0, min, sgn,ones,maxLLR;
                 ones   = _mm256_set1_epi8((char)1);
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z12_15_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z12_R15_AVX2.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z12_15_AVX2.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z12_R15_AVX2.c
index ce33d4fd26..9a78d5df60 100644
--- a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z12_15_AVX2.c
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z12_R15_AVX2.c
@@ -1,6 +1,6 @@
 #include <stdint.h>
 #include <immintrin.h>
-void nrLDPC_cnProc_BG2_Z12_15_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG2_Z12_R15_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m256i ymm0, min, sgn,ones,maxLLR;
                 ones   = _mm256_set1_epi8((char)1);
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z14_15_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z13_R15_AVX2.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z14_15_AVX2.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z13_R15_AVX2.c
index 58e832f471..59c963a8fc 100644
--- a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z14_15_AVX2.c
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z13_R15_AVX2.c
@@ -1,6 +1,6 @@
 #include <stdint.h>
 #include <immintrin.h>
-void nrLDPC_cnProc_BG2_Z14_15_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG2_Z13_R15_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m256i ymm0, min, sgn,ones,maxLLR;
                 ones   = _mm256_set1_epi8((char)1);
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z144_15_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z144_R15_AVX2.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z144_15_AVX2.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z144_R15_AVX2.c
index 58a3ede3de..66b3733d42 100644
--- a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z144_15_AVX2.c
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z144_R15_AVX2.c
@@ -1,6 +1,6 @@
 #include <stdint.h>
 #include <immintrin.h>
-void nrLDPC_cnProc_BG2_Z144_15_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG2_Z144_R15_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m256i ymm0, min, sgn,ones,maxLLR;
                 ones   = _mm256_set1_epi8((char)1);
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z13_15_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z14_R15_AVX2.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z13_15_AVX2.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z14_R15_AVX2.c
index de55c00b63..94c1e7cd3c 100644
--- a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z13_15_AVX2.c
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z14_R15_AVX2.c
@@ -1,6 +1,6 @@
 #include <stdint.h>
 #include <immintrin.h>
-void nrLDPC_cnProc_BG2_Z13_15_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG2_Z14_R15_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m256i ymm0, min, sgn,ones,maxLLR;
                 ones   = _mm256_set1_epi8((char)1);
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z15_15_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z15_R15_AVX2.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z15_15_AVX2.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z15_R15_AVX2.c
index 836b8728b0..e50fd26998 100644
--- a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z15_15_AVX2.c
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z15_R15_AVX2.c
@@ -1,6 +1,6 @@
 #include <stdint.h>
 #include <immintrin.h>
-void nrLDPC_cnProc_BG2_Z15_15_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG2_Z15_R15_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m256i ymm0, min, sgn,ones,maxLLR;
                 ones   = _mm256_set1_epi8((char)1);
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z160_15_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z160_R15_AVX2.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z160_15_AVX2.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z160_R15_AVX2.c
index 80dd283883..e6472f526c 100644
--- a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z160_15_AVX2.c
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z160_R15_AVX2.c
@@ -1,6 +1,6 @@
 #include <stdint.h>
 #include <immintrin.h>
-void nrLDPC_cnProc_BG2_Z160_15_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG2_Z160_R15_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m256i ymm0, min, sgn,ones,maxLLR;
                 ones   = _mm256_set1_epi8((char)1);
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z16_15_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z16_R15_AVX2.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z16_15_AVX2.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z16_R15_AVX2.c
index b895cdcd9b..3d05fd089b 100644
--- a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z16_15_AVX2.c
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z16_R15_AVX2.c
@@ -1,6 +1,6 @@
 #include <stdint.h>
 #include <immintrin.h>
-void nrLDPC_cnProc_BG2_Z16_15_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG2_Z16_R15_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m256i ymm0, min, sgn,ones,maxLLR;
                 ones   = _mm256_set1_epi8((char)1);
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z176_15_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z176_R15_AVX2.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z176_15_AVX2.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z176_R15_AVX2.c
index cf88db079a..0f14028b6d 100644
--- a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z176_15_AVX2.c
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z176_R15_AVX2.c
@@ -1,6 +1,6 @@
 #include <stdint.h>
 #include <immintrin.h>
-void nrLDPC_cnProc_BG2_Z176_15_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG2_Z176_R15_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m256i ymm0, min, sgn,ones,maxLLR;
                 ones   = _mm256_set1_epi8((char)1);
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z18_15_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z18_R15_AVX2.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z18_15_AVX2.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z18_R15_AVX2.c
index ba94cfc0bb..8e44a92165 100644
--- a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z18_15_AVX2.c
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z18_R15_AVX2.c
@@ -1,6 +1,6 @@
 #include <stdint.h>
 #include <immintrin.h>
-void nrLDPC_cnProc_BG2_Z18_15_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG2_Z18_R15_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m256i ymm0, min, sgn,ones,maxLLR;
                 ones   = _mm256_set1_epi8((char)1);
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z192_15_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z192_R15_AVX2.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z192_15_AVX2.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z192_R15_AVX2.c
index 063a7057b7..b56aabf024 100644
--- a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z192_15_AVX2.c
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z192_R15_AVX2.c
@@ -1,6 +1,6 @@
 #include <stdint.h>
 #include <immintrin.h>
-void nrLDPC_cnProc_BG2_Z192_15_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG2_Z192_R15_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m256i ymm0, min, sgn,ones,maxLLR;
                 ones   = _mm256_set1_epi8((char)1);
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z208_15_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z208_R15_AVX2.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z208_15_AVX2.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z208_R15_AVX2.c
index 1ee56ee181..0a0ff67520 100644
--- a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z208_15_AVX2.c
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z208_R15_AVX2.c
@@ -1,6 +1,6 @@
 #include <stdint.h>
 #include <immintrin.h>
-void nrLDPC_cnProc_BG2_Z208_15_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG2_Z208_R15_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m256i ymm0, min, sgn,ones,maxLLR;
                 ones   = _mm256_set1_epi8((char)1);
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z20_15_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z20_R15_AVX2.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z20_15_AVX2.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z20_R15_AVX2.c
index 65fc929bc4..59c3246689 100644
--- a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z20_15_AVX2.c
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z20_R15_AVX2.c
@@ -1,6 +1,6 @@
 #include <stdint.h>
 #include <immintrin.h>
-void nrLDPC_cnProc_BG2_Z20_15_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG2_Z20_R15_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m256i ymm0, min, sgn,ones,maxLLR;
                 ones   = _mm256_set1_epi8((char)1);
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z224_15_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z224_R15_AVX2.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z224_15_AVX2.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z224_R15_AVX2.c
index b5e3c5d0fe..13f778a24c 100644
--- a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z224_15_AVX2.c
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z224_R15_AVX2.c
@@ -1,6 +1,6 @@
 #include <stdint.h>
 #include <immintrin.h>
-void nrLDPC_cnProc_BG2_Z224_15_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG2_Z224_R15_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m256i ymm0, min, sgn,ones,maxLLR;
                 ones   = _mm256_set1_epi8((char)1);
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z22_15_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z22_R15_AVX2.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z22_15_AVX2.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z22_R15_AVX2.c
index f9bb71d1e3..d6ea777549 100644
--- a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z22_15_AVX2.c
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z22_R15_AVX2.c
@@ -1,6 +1,6 @@
 #include <stdint.h>
 #include <immintrin.h>
-void nrLDPC_cnProc_BG2_Z22_15_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG2_Z22_R15_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m256i ymm0, min, sgn,ones,maxLLR;
                 ones   = _mm256_set1_epi8((char)1);
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z240_15_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z240_R15_AVX2.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z240_15_AVX2.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z240_R15_AVX2.c
index 605597165c..e73e53e2c1 100644
--- a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z240_15_AVX2.c
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z240_R15_AVX2.c
@@ -1,6 +1,6 @@
 #include <stdint.h>
 #include <immintrin.h>
-void nrLDPC_cnProc_BG2_Z240_15_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG2_Z240_R15_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m256i ymm0, min, sgn,ones,maxLLR;
                 ones   = _mm256_set1_epi8((char)1);
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z24_15_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z24_R15_AVX2.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z24_15_AVX2.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z24_R15_AVX2.c
index 4530ab3938..94456093a1 100644
--- a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z24_15_AVX2.c
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z24_R15_AVX2.c
@@ -1,6 +1,6 @@
 #include <stdint.h>
 #include <immintrin.h>
-void nrLDPC_cnProc_BG2_Z24_15_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG2_Z24_R15_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m256i ymm0, min, sgn,ones,maxLLR;
                 ones   = _mm256_set1_epi8((char)1);
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z256_15_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z256_R15_AVX2.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z256_15_AVX2.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z256_R15_AVX2.c
index c322cf09b3..ca030208df 100644
--- a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z256_15_AVX2.c
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z256_R15_AVX2.c
@@ -1,6 +1,6 @@
 #include <stdint.h>
 #include <immintrin.h>
-void nrLDPC_cnProc_BG2_Z256_15_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG2_Z256_R15_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m256i ymm0, min, sgn,ones,maxLLR;
                 ones   = _mm256_set1_epi8((char)1);
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z26_15_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z26_R15_AVX2.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z26_15_AVX2.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z26_R15_AVX2.c
index acdfa2b3ae..204fecce65 100644
--- a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z26_15_AVX2.c
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z26_R15_AVX2.c
@@ -1,6 +1,6 @@
 #include <stdint.h>
 #include <immintrin.h>
-void nrLDPC_cnProc_BG2_Z26_15_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG2_Z26_R15_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m256i ymm0, min, sgn,ones,maxLLR;
                 ones   = _mm256_set1_epi8((char)1);
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z288_15_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z288_R15_AVX2.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z288_15_AVX2.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z288_R15_AVX2.c
index 2296b423b2..ddcdfe2377 100644
--- a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z288_15_AVX2.c
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z288_R15_AVX2.c
@@ -1,6 +1,6 @@
 #include <stdint.h>
 #include <immintrin.h>
-void nrLDPC_cnProc_BG2_Z288_15_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG2_Z288_R15_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m256i ymm0, min, sgn,ones,maxLLR;
                 ones   = _mm256_set1_epi8((char)1);
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z28_15_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z28_R15_AVX2.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z28_15_AVX2.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z28_R15_AVX2.c
index 85e251cc70..25581f51f9 100644
--- a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z28_15_AVX2.c
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z28_R15_AVX2.c
@@ -1,6 +1,6 @@
 #include <stdint.h>
 #include <immintrin.h>
-void nrLDPC_cnProc_BG2_Z28_15_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG2_Z28_R15_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m256i ymm0, min, sgn,ones,maxLLR;
                 ones   = _mm256_set1_epi8((char)1);
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z2_15_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z2_R15_AVX2.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z2_15_AVX2.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z2_R15_AVX2.c
index a91c642933..df34bf42be 100644
--- a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z2_15_AVX2.c
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z2_R15_AVX2.c
@@ -1,6 +1,6 @@
 #include <stdint.h>
 #include <immintrin.h>
-void nrLDPC_cnProc_BG2_Z2_15_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG2_Z2_R15_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m256i ymm0, min, sgn,ones,maxLLR;
                 ones   = _mm256_set1_epi8((char)1);
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z30_15_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z30_R15_AVX2.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z30_15_AVX2.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z30_R15_AVX2.c
index 484fb6412c..4270e115bf 100644
--- a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z30_15_AVX2.c
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z30_R15_AVX2.c
@@ -1,6 +1,6 @@
 #include <stdint.h>
 #include <immintrin.h>
-void nrLDPC_cnProc_BG2_Z30_15_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG2_Z30_R15_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m256i ymm0, min, sgn,ones,maxLLR;
                 ones   = _mm256_set1_epi8((char)1);
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z320_15_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z320_R15_AVX2.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z320_15_AVX2.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z320_R15_AVX2.c
index 00c4a16d51..b86af8cc26 100644
--- a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z320_15_AVX2.c
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z320_R15_AVX2.c
@@ -1,6 +1,6 @@
 #include <stdint.h>
 #include <immintrin.h>
-void nrLDPC_cnProc_BG2_Z320_15_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG2_Z320_R15_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m256i ymm0, min, sgn,ones,maxLLR;
                 ones   = _mm256_set1_epi8((char)1);
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z32_15_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z32_R15_AVX2.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z32_15_AVX2.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z32_R15_AVX2.c
index 3612e960d4..b2fbd829b6 100644
--- a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z32_15_AVX2.c
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z32_R15_AVX2.c
@@ -1,6 +1,6 @@
 #include <stdint.h>
 #include <immintrin.h>
-void nrLDPC_cnProc_BG2_Z32_15_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG2_Z32_R15_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m256i ymm0, min, sgn,ones,maxLLR;
                 ones   = _mm256_set1_epi8((char)1);
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z352_15_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z352_R15_AVX2.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z352_15_AVX2.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z352_R15_AVX2.c
index 4d35ca9d3a..e2d692f5a6 100644
--- a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z352_15_AVX2.c
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z352_R15_AVX2.c
@@ -1,6 +1,6 @@
 #include <stdint.h>
 #include <immintrin.h>
-void nrLDPC_cnProc_BG2_Z352_15_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG2_Z352_R15_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m256i ymm0, min, sgn,ones,maxLLR;
                 ones   = _mm256_set1_epi8((char)1);
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z36_15_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z36_R15_AVX2.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z36_15_AVX2.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z36_R15_AVX2.c
index 6b2aa586aa..8d272ae764 100644
--- a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z36_15_AVX2.c
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z36_R15_AVX2.c
@@ -1,6 +1,6 @@
 #include <stdint.h>
 #include <immintrin.h>
-void nrLDPC_cnProc_BG2_Z36_15_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG2_Z36_R15_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m256i ymm0, min, sgn,ones,maxLLR;
                 ones   = _mm256_set1_epi8((char)1);
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z384_15_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z384_R15_AVX2.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z384_15_AVX2.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z384_R15_AVX2.c
index 140e16a03f..0130022c02 100644
--- a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z384_15_AVX2.c
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z384_R15_AVX2.c
@@ -1,6 +1,6 @@
 #include <stdint.h>
 #include <immintrin.h>
-void nrLDPC_cnProc_BG2_Z384_15_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG2_Z384_R15_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m256i ymm0, min, sgn,ones,maxLLR;
                 ones   = _mm256_set1_epi8((char)1);
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z3_15_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z3_R15_AVX2.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z3_15_AVX2.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z3_R15_AVX2.c
index b05c643e05..220cff34ed 100644
--- a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z3_15_AVX2.c
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z3_R15_AVX2.c
@@ -1,6 +1,6 @@
 #include <stdint.h>
 #include <immintrin.h>
-void nrLDPC_cnProc_BG2_Z3_15_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG2_Z3_R15_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m256i ymm0, min, sgn,ones,maxLLR;
                 ones   = _mm256_set1_epi8((char)1);
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z40_15_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z40_R15_AVX2.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z40_15_AVX2.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z40_R15_AVX2.c
index 55f94b4afc..c5373ed43e 100644
--- a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z40_15_AVX2.c
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z40_R15_AVX2.c
@@ -1,6 +1,6 @@
 #include <stdint.h>
 #include <immintrin.h>
-void nrLDPC_cnProc_BG2_Z40_15_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG2_Z40_R15_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m256i ymm0, min, sgn,ones,maxLLR;
                 ones   = _mm256_set1_epi8((char)1);
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z44_15_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z44_R15_AVX2.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z44_15_AVX2.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z44_R15_AVX2.c
index c3089fbc52..f9f1dd05ef 100644
--- a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z44_15_AVX2.c
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z44_R15_AVX2.c
@@ -1,6 +1,6 @@
 #include <stdint.h>
 #include <immintrin.h>
-void nrLDPC_cnProc_BG2_Z44_15_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG2_Z44_R15_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m256i ymm0, min, sgn,ones,maxLLR;
                 ones   = _mm256_set1_epi8((char)1);
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z48_15_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z48_R15_AVX2.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z48_15_AVX2.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z48_R15_AVX2.c
index 1d6b6a2bee..afc61d740d 100644
--- a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z48_15_AVX2.c
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z48_R15_AVX2.c
@@ -1,6 +1,6 @@
 #include <stdint.h>
 #include <immintrin.h>
-void nrLDPC_cnProc_BG2_Z48_15_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG2_Z48_R15_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m256i ymm0, min, sgn,ones,maxLLR;
                 ones   = _mm256_set1_epi8((char)1);
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z4_15_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z4_R15_AVX2.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z4_15_AVX2.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z4_R15_AVX2.c
index 896947350a..3835c214fc 100644
--- a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z4_15_AVX2.c
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z4_R15_AVX2.c
@@ -1,6 +1,6 @@
 #include <stdint.h>
 #include <immintrin.h>
-void nrLDPC_cnProc_BG2_Z4_15_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG2_Z4_R15_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m256i ymm0, min, sgn,ones,maxLLR;
                 ones   = _mm256_set1_epi8((char)1);
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z52_15_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z52_R15_AVX2.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z52_15_AVX2.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z52_R15_AVX2.c
index f93a52fa51..55039f44e9 100644
--- a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z52_15_AVX2.c
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z52_R15_AVX2.c
@@ -1,6 +1,6 @@
 #include <stdint.h>
 #include <immintrin.h>
-void nrLDPC_cnProc_BG2_Z52_15_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG2_Z52_R15_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m256i ymm0, min, sgn,ones,maxLLR;
                 ones   = _mm256_set1_epi8((char)1);
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z56_15_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z56_R15_AVX2.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z56_15_AVX2.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z56_R15_AVX2.c
index 1590dae7cb..9375f4e297 100644
--- a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z56_15_AVX2.c
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z56_R15_AVX2.c
@@ -1,6 +1,6 @@
 #include <stdint.h>
 #include <immintrin.h>
-void nrLDPC_cnProc_BG2_Z56_15_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG2_Z56_R15_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m256i ymm0, min, sgn,ones,maxLLR;
                 ones   = _mm256_set1_epi8((char)1);
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z5_15_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z5_R15_AVX2.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z5_15_AVX2.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z5_R15_AVX2.c
index f95d455b73..767a165818 100644
--- a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z5_15_AVX2.c
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z5_R15_AVX2.c
@@ -1,6 +1,6 @@
 #include <stdint.h>
 #include <immintrin.h>
-void nrLDPC_cnProc_BG2_Z5_15_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG2_Z5_R15_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m256i ymm0, min, sgn,ones,maxLLR;
                 ones   = _mm256_set1_epi8((char)1);
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z60_15_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z60_R15_AVX2.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z60_15_AVX2.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z60_R15_AVX2.c
index 0e06e58a73..4f2a9b8190 100644
--- a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z60_15_AVX2.c
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z60_R15_AVX2.c
@@ -1,6 +1,6 @@
 #include <stdint.h>
 #include <immintrin.h>
-void nrLDPC_cnProc_BG2_Z60_15_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG2_Z60_R15_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m256i ymm0, min, sgn,ones,maxLLR;
                 ones   = _mm256_set1_epi8((char)1);
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z64_15_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z64_R15_AVX2.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z64_15_AVX2.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z64_R15_AVX2.c
index 269753dbed..8d75ac2f70 100644
--- a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z64_15_AVX2.c
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z64_R15_AVX2.c
@@ -1,6 +1,6 @@
 #include <stdint.h>
 #include <immintrin.h>
-void nrLDPC_cnProc_BG2_Z64_15_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG2_Z64_R15_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m256i ymm0, min, sgn,ones,maxLLR;
                 ones   = _mm256_set1_epi8((char)1);
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z6_15_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z6_R15_AVX2.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z6_15_AVX2.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z6_R15_AVX2.c
index b0d719aa46..ce0932e069 100644
--- a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z6_15_AVX2.c
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z6_R15_AVX2.c
@@ -1,6 +1,6 @@
 #include <stdint.h>
 #include <immintrin.h>
-void nrLDPC_cnProc_BG2_Z6_15_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG2_Z6_R15_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m256i ymm0, min, sgn,ones,maxLLR;
                 ones   = _mm256_set1_epi8((char)1);
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z72_15_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z72_R15_AVX2.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z72_15_AVX2.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z72_R15_AVX2.c
index ae6a42bc2c..d343dedbef 100644
--- a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z72_15_AVX2.c
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z72_R15_AVX2.c
@@ -1,6 +1,6 @@
 #include <stdint.h>
 #include <immintrin.h>
-void nrLDPC_cnProc_BG2_Z72_15_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG2_Z72_R15_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m256i ymm0, min, sgn,ones,maxLLR;
                 ones   = _mm256_set1_epi8((char)1);
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z7_15_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z7_R15_AVX2.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z7_15_AVX2.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z7_R15_AVX2.c
index 66fd471d37..dfd5f3a395 100644
--- a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z7_15_AVX2.c
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z7_R15_AVX2.c
@@ -1,6 +1,6 @@
 #include <stdint.h>
 #include <immintrin.h>
-void nrLDPC_cnProc_BG2_Z7_15_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG2_Z7_R15_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m256i ymm0, min, sgn,ones,maxLLR;
                 ones   = _mm256_set1_epi8((char)1);
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z80_15_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z80_R15_AVX2.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z80_15_AVX2.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z80_R15_AVX2.c
index 769400769c..0b7de6d364 100644
--- a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z80_15_AVX2.c
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z80_R15_AVX2.c
@@ -1,6 +1,6 @@
 #include <stdint.h>
 #include <immintrin.h>
-void nrLDPC_cnProc_BG2_Z80_15_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG2_Z80_R15_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m256i ymm0, min, sgn,ones,maxLLR;
                 ones   = _mm256_set1_epi8((char)1);
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z88_15_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z88_R15_AVX2.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z88_15_AVX2.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z88_R15_AVX2.c
index 42910fcbfb..236d3af15f 100644
--- a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z88_15_AVX2.c
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z88_R15_AVX2.c
@@ -1,6 +1,6 @@
 #include <stdint.h>
 #include <immintrin.h>
-void nrLDPC_cnProc_BG2_Z88_15_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG2_Z88_R15_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m256i ymm0, min, sgn,ones,maxLLR;
                 ones   = _mm256_set1_epi8((char)1);
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z8_15_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z8_R15_AVX2.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z8_15_AVX2.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z8_R15_AVX2.c
index 209af063fc..ddc6a7acb0 100644
--- a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z8_15_AVX2.c
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z8_R15_AVX2.c
@@ -1,6 +1,6 @@
 #include <stdint.h>
 #include <immintrin.h>
-void nrLDPC_cnProc_BG2_Z8_15_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG2_Z8_R15_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m256i ymm0, min, sgn,ones,maxLLR;
                 ones   = _mm256_set1_epi8((char)1);
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z96_15_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z96_R15_AVX2.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z96_15_AVX2.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z96_R15_AVX2.c
index 15f350d61b..3ee2a5135a 100644
--- a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z96_15_AVX2.c
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z96_R15_AVX2.c
@@ -1,6 +1,6 @@
 #include <stdint.h>
 #include <immintrin.h>
-void nrLDPC_cnProc_BG2_Z96_15_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG2_Z96_R15_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m256i ymm0, min, sgn,ones,maxLLR;
                 ones   = _mm256_set1_epi8((char)1);
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z9_15_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z9_R15_AVX2.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z9_15_AVX2.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z9_R15_AVX2.c
index acc0842f9a..f076359378 100644
--- a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG2_Z9_15_AVX2.c
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/cnProc/nrLDPC_cnProc_BG2_Z9_R15_AVX2.c
@@ -1,6 +1,6 @@
 #include <stdint.h>
 #include <immintrin.h>
-void nrLDPC_cnProc_BG2_Z9_15_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG2_Z9_R15_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m256i ymm0, min, sgn,ones,maxLLR;
                 ones   = _mm256_set1_epi8((char)1);
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_R13_AVX512.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z104_13_AVX512.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z104_R13_AVX512.c
index 7090e88659..9ce1b21dbf 100644
--- 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_R13_AVX512.c
@@ -1,7 +1,7 @@
 #include <stdint.h>
 #include <immintrin.h>
 #define conditional_negate(a,b,z) _mm512_mask_sub_epi8(a,_mm512_movepi8_mask(b),z,a)
-void nrLDPC_cnProc_BG1_Z104_13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG1_Z104_R13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m512i zmm0, min, sgn,zeros,maxLLR;
                 zeros  = _mm512_setzero_si512();
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_Z10_R13_AVX512.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z9_13_AVX512.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z10_R13_AVX512.c
index c8b210c8a2..931aabc9e6 100644
--- 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_Z10_R13_AVX512.c
@@ -1,7 +1,7 @@
 #include <stdint.h>
 #include <immintrin.h>
 #define conditional_negate(a,b,z) _mm512_mask_sub_epi8(a,_mm512_movepi8_mask(b),z,a)
-void nrLDPC_cnProc_BG1_Z9_13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG1_Z10_R13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m512i zmm0, min, sgn,zeros,maxLLR;
                 zeros  = _mm512_setzero_si512();
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_R13_AVX512.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z112_13_AVX512.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z112_R13_AVX512.c
index 46af61917a..58776ecedc 100644
--- 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_R13_AVX512.c
@@ -1,7 +1,7 @@
 #include <stdint.h>
 #include <immintrin.h>
 #define conditional_negate(a,b,z) _mm512_mask_sub_epi8(a,_mm512_movepi8_mask(b),z,a)
-void nrLDPC_cnProc_BG1_Z112_13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG1_Z112_R13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m512i zmm0, min, sgn,zeros,maxLLR;
                 zeros  = _mm512_setzero_si512();
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_Z11_R13_AVX512.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z12_13_AVX512.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z11_R13_AVX512.c
index 2b2a2e80eb..2aeb54ea5e 100644
--- 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_Z11_R13_AVX512.c
@@ -1,7 +1,7 @@
 #include <stdint.h>
 #include <immintrin.h>
 #define conditional_negate(a,b,z) _mm512_mask_sub_epi8(a,_mm512_movepi8_mask(b),z,a)
-void nrLDPC_cnProc_BG1_Z12_13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG1_Z11_R13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m512i zmm0, min, sgn,zeros,maxLLR;
                 zeros  = _mm512_setzero_si512();
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_R13_AVX512.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z120_13_AVX512.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z120_R13_AVX512.c
index 0422bb7415..f18f5526bd 100644
--- 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_R13_AVX512.c
@@ -1,7 +1,7 @@
 #include <stdint.h>
 #include <immintrin.h>
 #define conditional_negate(a,b,z) _mm512_mask_sub_epi8(a,_mm512_movepi8_mask(b),z,a)
-void nrLDPC_cnProc_BG1_Z120_13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG1_Z120_R13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m512i zmm0, min, sgn,zeros,maxLLR;
                 zeros  = _mm512_setzero_si512();
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_R13_AVX512.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z128_13_AVX512.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z128_R13_AVX512.c
index 2bb9a39a86..a9aa7d52fc 100644
--- 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_R13_AVX512.c
@@ -1,7 +1,7 @@
 #include <stdint.h>
 #include <immintrin.h>
 #define conditional_negate(a,b,z) _mm512_mask_sub_epi8(a,_mm512_movepi8_mask(b),z,a)
-void nrLDPC_cnProc_BG1_Z128_13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG1_Z128_R13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m512i zmm0, min, sgn,zeros,maxLLR;
                 zeros  = _mm512_setzero_si512();
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_Z12_R13_AVX512.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z11_13_AVX512.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z12_R13_AVX512.c
index 6db79c76db..799c26e91e 100644
--- 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_Z12_R13_AVX512.c
@@ -1,7 +1,7 @@
 #include <stdint.h>
 #include <immintrin.h>
 #define conditional_negate(a,b,z) _mm512_mask_sub_epi8(a,_mm512_movepi8_mask(b),z,a)
-void nrLDPC_cnProc_BG1_Z11_13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG1_Z12_R13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m512i zmm0, min, sgn,zeros,maxLLR;
                 zeros  = _mm512_setzero_si512();
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_R13_AVX512.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z13_13_AVX512.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z13_R13_AVX512.c
index af39ffbbe0..394b57a483 100644
--- 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_R13_AVX512.c
@@ -1,7 +1,7 @@
 #include <stdint.h>
 #include <immintrin.h>
 #define conditional_negate(a,b,z) _mm512_mask_sub_epi8(a,_mm512_movepi8_mask(b),z,a)
-void nrLDPC_cnProc_BG1_Z13_13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG1_Z13_R13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m512i zmm0, min, sgn,zeros,maxLLR;
                 zeros  = _mm512_setzero_si512();
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_R13_AVX512.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z144_13_AVX512.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z144_R13_AVX512.c
index b0caad9435..1ec0abd30e 100644
--- 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_R13_AVX512.c
@@ -1,7 +1,7 @@
 #include <stdint.h>
 #include <immintrin.h>
 #define conditional_negate(a,b,z) _mm512_mask_sub_epi8(a,_mm512_movepi8_mask(b),z,a)
-void nrLDPC_cnProc_BG1_Z144_13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG1_Z144_R13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m512i zmm0, min, sgn,zeros,maxLLR;
                 zeros  = _mm512_setzero_si512();
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_R13_AVX512.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z14_13_AVX512.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z14_R13_AVX512.c
index 587dfe323a..0bf5c532bc 100644
--- 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_R13_AVX512.c
@@ -1,7 +1,7 @@
 #include <stdint.h>
 #include <immintrin.h>
 #define conditional_negate(a,b,z) _mm512_mask_sub_epi8(a,_mm512_movepi8_mask(b),z,a)
-void nrLDPC_cnProc_BG1_Z14_13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG1_Z14_R13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m512i zmm0, min, sgn,zeros,maxLLR;
                 zeros  = _mm512_setzero_si512();
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_R13_AVX512.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z15_13_AVX512.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z15_R13_AVX512.c
index 9fc63c424f..21cc303172 100644
--- 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_R13_AVX512.c
@@ -1,7 +1,7 @@
 #include <stdint.h>
 #include <immintrin.h>
 #define conditional_negate(a,b,z) _mm512_mask_sub_epi8(a,_mm512_movepi8_mask(b),z,a)
-void nrLDPC_cnProc_BG1_Z15_13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG1_Z15_R13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m512i zmm0, min, sgn,zeros,maxLLR;
                 zeros  = _mm512_setzero_si512();
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_R13_AVX512.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z160_13_AVX512.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z160_R13_AVX512.c
index 51a4cc7e16..ace2e27399 100644
--- 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_R13_AVX512.c
@@ -1,7 +1,7 @@
 #include <stdint.h>
 #include <immintrin.h>
 #define conditional_negate(a,b,z) _mm512_mask_sub_epi8(a,_mm512_movepi8_mask(b),z,a)
-void nrLDPC_cnProc_BG1_Z160_13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG1_Z160_R13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m512i zmm0, min, sgn,zeros,maxLLR;
                 zeros  = _mm512_setzero_si512();
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_R13_AVX512.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z16_13_AVX512.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z16_R13_AVX512.c
index eb0477a6f8..897bf3b12a 100644
--- 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_R13_AVX512.c
@@ -1,7 +1,7 @@
 #include <stdint.h>
 #include <immintrin.h>
 #define conditional_negate(a,b,z) _mm512_mask_sub_epi8(a,_mm512_movepi8_mask(b),z,a)
-void nrLDPC_cnProc_BG1_Z16_13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG1_Z16_R13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m512i zmm0, min, sgn,zeros,maxLLR;
                 zeros  = _mm512_setzero_si512();
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_R13_AVX512.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z176_13_AVX512.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z176_R13_AVX512.c
index 50d4ea6cf9..bafb9cd106 100644
--- 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_R13_AVX512.c
@@ -1,7 +1,7 @@
 #include <stdint.h>
 #include <immintrin.h>
 #define conditional_negate(a,b,z) _mm512_mask_sub_epi8(a,_mm512_movepi8_mask(b),z,a)
-void nrLDPC_cnProc_BG1_Z176_13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG1_Z176_R13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m512i zmm0, min, sgn,zeros,maxLLR;
                 zeros  = _mm512_setzero_si512();
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_R13_AVX512.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z18_13_AVX512.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z18_R13_AVX512.c
index 23af4309f9..dd4c008f1d 100644
--- 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_R13_AVX512.c
@@ -1,7 +1,7 @@
 #include <stdint.h>
 #include <immintrin.h>
 #define conditional_negate(a,b,z) _mm512_mask_sub_epi8(a,_mm512_movepi8_mask(b),z,a)
-void nrLDPC_cnProc_BG1_Z18_13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG1_Z18_R13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m512i zmm0, min, sgn,zeros,maxLLR;
                 zeros  = _mm512_setzero_si512();
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_R13_AVX512.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z192_13_AVX512.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z192_R13_AVX512.c
index f4d9331801..f9c4deca35 100644
--- 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_R13_AVX512.c
@@ -1,7 +1,7 @@
 #include <stdint.h>
 #include <immintrin.h>
 #define conditional_negate(a,b,z) _mm512_mask_sub_epi8(a,_mm512_movepi8_mask(b),z,a)
-void nrLDPC_cnProc_BG1_Z192_13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG1_Z192_R13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m512i zmm0, min, sgn,zeros,maxLLR;
                 zeros  = _mm512_setzero_si512();
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_R13_AVX512.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z208_13_AVX512.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z208_R13_AVX512.c
index fc2d4598d9..8dd282f1f6 100644
--- 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_R13_AVX512.c
@@ -1,7 +1,7 @@
 #include <stdint.h>
 #include <immintrin.h>
 #define conditional_negate(a,b,z) _mm512_mask_sub_epi8(a,_mm512_movepi8_mask(b),z,a)
-void nrLDPC_cnProc_BG1_Z208_13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG1_Z208_R13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m512i zmm0, min, sgn,zeros,maxLLR;
                 zeros  = _mm512_setzero_si512();
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_R13_AVX512.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z20_13_AVX512.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z20_R13_AVX512.c
index c1812d6cdf..65ba354529 100644
--- 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_R13_AVX512.c
@@ -1,7 +1,7 @@
 #include <stdint.h>
 #include <immintrin.h>
 #define conditional_negate(a,b,z) _mm512_mask_sub_epi8(a,_mm512_movepi8_mask(b),z,a)
-void nrLDPC_cnProc_BG1_Z20_13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG1_Z20_R13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m512i zmm0, min, sgn,zeros,maxLLR;
                 zeros  = _mm512_setzero_si512();
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_R13_AVX512.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z224_13_AVX512.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z224_R13_AVX512.c
index a3712dd094..76e8d7916d 100644
--- 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_R13_AVX512.c
@@ -1,7 +1,7 @@
 #include <stdint.h>
 #include <immintrin.h>
 #define conditional_negate(a,b,z) _mm512_mask_sub_epi8(a,_mm512_movepi8_mask(b),z,a)
-void nrLDPC_cnProc_BG1_Z224_13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG1_Z224_R13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m512i zmm0, min, sgn,zeros,maxLLR;
                 zeros  = _mm512_setzero_si512();
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_R13_AVX512.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z22_13_AVX512.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z22_R13_AVX512.c
index e57a6940bb..c619f1fa92 100644
--- 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_R13_AVX512.c
@@ -1,7 +1,7 @@
 #include <stdint.h>
 #include <immintrin.h>
 #define conditional_negate(a,b,z) _mm512_mask_sub_epi8(a,_mm512_movepi8_mask(b),z,a)
-void nrLDPC_cnProc_BG1_Z22_13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG1_Z22_R13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m512i zmm0, min, sgn,zeros,maxLLR;
                 zeros  = _mm512_setzero_si512();
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_R13_AVX512.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z240_13_AVX512.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z240_R13_AVX512.c
index 547fe81421..6f6334f753 100644
--- 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_R13_AVX512.c
@@ -1,7 +1,7 @@
 #include <stdint.h>
 #include <immintrin.h>
 #define conditional_negate(a,b,z) _mm512_mask_sub_epi8(a,_mm512_movepi8_mask(b),z,a)
-void nrLDPC_cnProc_BG1_Z240_13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG1_Z240_R13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m512i zmm0, min, sgn,zeros,maxLLR;
                 zeros  = _mm512_setzero_si512();
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_R13_AVX512.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z24_13_AVX512.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z24_R13_AVX512.c
index a82c63869b..94459877a7 100644
--- 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_R13_AVX512.c
@@ -1,7 +1,7 @@
 #include <stdint.h>
 #include <immintrin.h>
 #define conditional_negate(a,b,z) _mm512_mask_sub_epi8(a,_mm512_movepi8_mask(b),z,a)
-void nrLDPC_cnProc_BG1_Z24_13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG1_Z24_R13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m512i zmm0, min, sgn,zeros,maxLLR;
                 zeros  = _mm512_setzero_si512();
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_R13_AVX512.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z256_13_AVX512.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z256_R13_AVX512.c
index b52b8b6d80..7f44b51d52 100644
--- 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_R13_AVX512.c
@@ -1,7 +1,7 @@
 #include <stdint.h>
 #include <immintrin.h>
 #define conditional_negate(a,b,z) _mm512_mask_sub_epi8(a,_mm512_movepi8_mask(b),z,a)
-void nrLDPC_cnProc_BG1_Z256_13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG1_Z256_R13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m512i zmm0, min, sgn,zeros,maxLLR;
                 zeros  = _mm512_setzero_si512();
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_R13_AVX512.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z26_13_AVX512.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z26_R13_AVX512.c
index 3a38553649..78403121b7 100644
--- 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_R13_AVX512.c
@@ -1,7 +1,7 @@
 #include <stdint.h>
 #include <immintrin.h>
 #define conditional_negate(a,b,z) _mm512_mask_sub_epi8(a,_mm512_movepi8_mask(b),z,a)
-void nrLDPC_cnProc_BG1_Z26_13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG1_Z26_R13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m512i zmm0, min, sgn,zeros,maxLLR;
                 zeros  = _mm512_setzero_si512();
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_R13_AVX512.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z288_13_AVX512.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z288_R13_AVX512.c
index 021d7ebc06..eb69908998 100644
--- 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_R13_AVX512.c
@@ -1,7 +1,7 @@
 #include <stdint.h>
 #include <immintrin.h>
 #define conditional_negate(a,b,z) _mm512_mask_sub_epi8(a,_mm512_movepi8_mask(b),z,a)
-void nrLDPC_cnProc_BG1_Z288_13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG1_Z288_R13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m512i zmm0, min, sgn,zeros,maxLLR;
                 zeros  = _mm512_setzero_si512();
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_R13_AVX512.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z28_13_AVX512.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z28_R13_AVX512.c
index f9a3dc4d78..6d125fb6bc 100644
--- 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_R13_AVX512.c
@@ -1,7 +1,7 @@
 #include <stdint.h>
 #include <immintrin.h>
 #define conditional_negate(a,b,z) _mm512_mask_sub_epi8(a,_mm512_movepi8_mask(b),z,a)
-void nrLDPC_cnProc_BG1_Z28_13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG1_Z28_R13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m512i zmm0, min, sgn,zeros,maxLLR;
                 zeros  = _mm512_setzero_si512();
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_Z2_R13_AVX512.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z3_13_AVX512.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z2_R13_AVX512.c
index 0d61a00fd6..ad0d6936fe 100644
--- 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_Z2_R13_AVX512.c
@@ -1,7 +1,7 @@
 #include <stdint.h>
 #include <immintrin.h>
 #define conditional_negate(a,b,z) _mm512_mask_sub_epi8(a,_mm512_movepi8_mask(b),z,a)
-void nrLDPC_cnProc_BG1_Z3_13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG1_Z2_R13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m512i zmm0, min, sgn,zeros,maxLLR;
                 zeros  = _mm512_setzero_si512();
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_R13_AVX512.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z30_13_AVX512.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z30_R13_AVX512.c
index 3577d0408c..2ff2574d9a 100644
--- 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_R13_AVX512.c
@@ -1,7 +1,7 @@
 #include <stdint.h>
 #include <immintrin.h>
 #define conditional_negate(a,b,z) _mm512_mask_sub_epi8(a,_mm512_movepi8_mask(b),z,a)
-void nrLDPC_cnProc_BG1_Z30_13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG1_Z30_R13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m512i zmm0, min, sgn,zeros,maxLLR;
                 zeros  = _mm512_setzero_si512();
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_R13_AVX512.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z320_13_AVX512.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z320_R13_AVX512.c
index 481d3cfb57..19f323d1f8 100644
--- 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_R13_AVX512.c
@@ -1,7 +1,7 @@
 #include <stdint.h>
 #include <immintrin.h>
 #define conditional_negate(a,b,z) _mm512_mask_sub_epi8(a,_mm512_movepi8_mask(b),z,a)
-void nrLDPC_cnProc_BG1_Z320_13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG1_Z320_R13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m512i zmm0, min, sgn,zeros,maxLLR;
                 zeros  = _mm512_setzero_si512();
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_R13_AVX512.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z32_13_AVX512.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z32_R13_AVX512.c
index 948ef9011e..aee2cc1b0e 100644
--- 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_R13_AVX512.c
@@ -1,7 +1,7 @@
 #include <stdint.h>
 #include <immintrin.h>
 #define conditional_negate(a,b,z) _mm512_mask_sub_epi8(a,_mm512_movepi8_mask(b),z,a)
-void nrLDPC_cnProc_BG1_Z32_13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG1_Z32_R13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m512i zmm0, min, sgn,zeros,maxLLR;
                 zeros  = _mm512_setzero_si512();
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_R13_AVX512.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z352_13_AVX512.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z352_R13_AVX512.c
index 0e1403eab1..27d8374f1d 100644
--- 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_R13_AVX512.c
@@ -1,7 +1,7 @@
 #include <stdint.h>
 #include <immintrin.h>
 #define conditional_negate(a,b,z) _mm512_mask_sub_epi8(a,_mm512_movepi8_mask(b),z,a)
-void nrLDPC_cnProc_BG1_Z352_13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG1_Z352_R13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m512i zmm0, min, sgn,zeros,maxLLR;
                 zeros  = _mm512_setzero_si512();
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_R13_AVX512.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z36_13_AVX512.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z36_R13_AVX512.c
index 47a3ac7eb5..2cbae94587 100644
--- 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_R13_AVX512.c
@@ -1,7 +1,7 @@
 #include <stdint.h>
 #include <immintrin.h>
 #define conditional_negate(a,b,z) _mm512_mask_sub_epi8(a,_mm512_movepi8_mask(b),z,a)
-void nrLDPC_cnProc_BG1_Z36_13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG1_Z36_R13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m512i zmm0, min, sgn,zeros,maxLLR;
                 zeros  = _mm512_setzero_si512();
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_R13_AVX512.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z384_13_AVX512.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z384_R13_AVX512.c
index e28d5adbb4..be72a37443 100644
--- 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_R13_AVX512.c
@@ -1,7 +1,7 @@
 #include <stdint.h>
 #include <immintrin.h>
 #define conditional_negate(a,b,z) _mm512_mask_sub_epi8(a,_mm512_movepi8_mask(b),z,a)
-void nrLDPC_cnProc_BG1_Z384_13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG1_Z384_R13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m512i zmm0, min, sgn,zeros,maxLLR;
                 zeros  = _mm512_setzero_si512();
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_Z3_R13_AVX512.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z2_13_AVX512.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z3_R13_AVX512.c
index 28cd588dd5..bcfba0de03 100644
--- 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_Z3_R13_AVX512.c
@@ -1,7 +1,7 @@
 #include <stdint.h>
 #include <immintrin.h>
 #define conditional_negate(a,b,z) _mm512_mask_sub_epi8(a,_mm512_movepi8_mask(b),z,a)
-void nrLDPC_cnProc_BG1_Z2_13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG1_Z3_R13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m512i zmm0, min, sgn,zeros,maxLLR;
                 zeros  = _mm512_setzero_si512();
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_R13_AVX512.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z40_13_AVX512.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z40_R13_AVX512.c
index 8d64735af7..7e022c9691 100644
--- 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_R13_AVX512.c
@@ -1,7 +1,7 @@
 #include <stdint.h>
 #include <immintrin.h>
 #define conditional_negate(a,b,z) _mm512_mask_sub_epi8(a,_mm512_movepi8_mask(b),z,a)
-void nrLDPC_cnProc_BG1_Z40_13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG1_Z40_R13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m512i zmm0, min, sgn,zeros,maxLLR;
                 zeros  = _mm512_setzero_si512();
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_R13_AVX512.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z44_13_AVX512.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z44_R13_AVX512.c
index 9b7179e26c..11908574d7 100644
--- 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_R13_AVX512.c
@@ -1,7 +1,7 @@
 #include <stdint.h>
 #include <immintrin.h>
 #define conditional_negate(a,b,z) _mm512_mask_sub_epi8(a,_mm512_movepi8_mask(b),z,a)
-void nrLDPC_cnProc_BG1_Z44_13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG1_Z44_R13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m512i zmm0, min, sgn,zeros,maxLLR;
                 zeros  = _mm512_setzero_si512();
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_R13_AVX512.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z48_13_AVX512.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z48_R13_AVX512.c
index d3483cc5db..dcf9d48363 100644
--- 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_R13_AVX512.c
@@ -1,7 +1,7 @@
 #include <stdint.h>
 #include <immintrin.h>
 #define conditional_negate(a,b,z) _mm512_mask_sub_epi8(a,_mm512_movepi8_mask(b),z,a)
-void nrLDPC_cnProc_BG1_Z48_13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG1_Z48_R13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m512i zmm0, min, sgn,zeros,maxLLR;
                 zeros  = _mm512_setzero_si512();
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_Z4_R13_AVX512.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z6_13_AVX512.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z4_R13_AVX512.c
index 1fb8a310ab..4fee7d3af5 100644
--- 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_Z4_R13_AVX512.c
@@ -1,7 +1,7 @@
 #include <stdint.h>
 #include <immintrin.h>
 #define conditional_negate(a,b,z) _mm512_mask_sub_epi8(a,_mm512_movepi8_mask(b),z,a)
-void nrLDPC_cnProc_BG1_Z6_13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG1_Z4_R13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m512i zmm0, min, sgn,zeros,maxLLR;
                 zeros  = _mm512_setzero_si512();
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_R13_AVX512.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z52_13_AVX512.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z52_R13_AVX512.c
index e23a9003fc..5d0a8c9862 100644
--- 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_R13_AVX512.c
@@ -1,7 +1,7 @@
 #include <stdint.h>
 #include <immintrin.h>
 #define conditional_negate(a,b,z) _mm512_mask_sub_epi8(a,_mm512_movepi8_mask(b),z,a)
-void nrLDPC_cnProc_BG1_Z52_13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG1_Z52_R13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m512i zmm0, min, sgn,zeros,maxLLR;
                 zeros  = _mm512_setzero_si512();
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_R13_AVX512.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z56_13_AVX512.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z56_R13_AVX512.c
index 72d3b15771..0c0a6bc09c 100644
--- 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_R13_AVX512.c
@@ -1,7 +1,7 @@
 #include <stdint.h>
 #include <immintrin.h>
 #define conditional_negate(a,b,z) _mm512_mask_sub_epi8(a,_mm512_movepi8_mask(b),z,a)
-void nrLDPC_cnProc_BG1_Z56_13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG1_Z56_R13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m512i zmm0, min, sgn,zeros,maxLLR;
                 zeros  = _mm512_setzero_si512();
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_Z5_R13_AVX512.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z4_13_AVX512.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z5_R13_AVX512.c
index e3a32db495..0eaf965c08 100644
--- 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_Z5_R13_AVX512.c
@@ -1,7 +1,7 @@
 #include <stdint.h>
 #include <immintrin.h>
 #define conditional_negate(a,b,z) _mm512_mask_sub_epi8(a,_mm512_movepi8_mask(b),z,a)
-void nrLDPC_cnProc_BG1_Z4_13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG1_Z5_R13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m512i zmm0, min, sgn,zeros,maxLLR;
                 zeros  = _mm512_setzero_si512();
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_R13_AVX512.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z60_13_AVX512.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z60_R13_AVX512.c
index df5670b10f..0dfb581d3a 100644
--- 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_R13_AVX512.c
@@ -1,7 +1,7 @@
 #include <stdint.h>
 #include <immintrin.h>
 #define conditional_negate(a,b,z) _mm512_mask_sub_epi8(a,_mm512_movepi8_mask(b),z,a)
-void nrLDPC_cnProc_BG1_Z60_13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG1_Z60_R13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m512i zmm0, min, sgn,zeros,maxLLR;
                 zeros  = _mm512_setzero_si512();
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_R13_AVX512.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z64_13_AVX512.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z64_R13_AVX512.c
index c3addcbd48..e4cfc593d2 100644
--- 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_R13_AVX512.c
@@ -1,7 +1,7 @@
 #include <stdint.h>
 #include <immintrin.h>
 #define conditional_negate(a,b,z) _mm512_mask_sub_epi8(a,_mm512_movepi8_mask(b),z,a)
-void nrLDPC_cnProc_BG1_Z64_13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG1_Z64_R13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m512i zmm0, min, sgn,zeros,maxLLR;
                 zeros  = _mm512_setzero_si512();
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_Z6_R13_AVX512.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z5_13_AVX512.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z6_R13_AVX512.c
index 2e5adf5f34..d1e3aea863 100644
--- 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_Z6_R13_AVX512.c
@@ -1,7 +1,7 @@
 #include <stdint.h>
 #include <immintrin.h>
 #define conditional_negate(a,b,z) _mm512_mask_sub_epi8(a,_mm512_movepi8_mask(b),z,a)
-void nrLDPC_cnProc_BG1_Z5_13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG1_Z6_R13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m512i zmm0, min, sgn,zeros,maxLLR;
                 zeros  = _mm512_setzero_si512();
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_R13_AVX512.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z72_13_AVX512.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z72_R13_AVX512.c
index 5f6e1e3946..7b948004e8 100644
--- 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_R13_AVX512.c
@@ -1,7 +1,7 @@
 #include <stdint.h>
 #include <immintrin.h>
 #define conditional_negate(a,b,z) _mm512_mask_sub_epi8(a,_mm512_movepi8_mask(b),z,a)
-void nrLDPC_cnProc_BG1_Z72_13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG1_Z72_R13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m512i zmm0, min, sgn,zeros,maxLLR;
                 zeros  = _mm512_setzero_si512();
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_R13_AVX512.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z7_13_AVX512.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z7_R13_AVX512.c
index 21f4623647..9685d28413 100644
--- 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_R13_AVX512.c
@@ -1,7 +1,7 @@
 #include <stdint.h>
 #include <immintrin.h>
 #define conditional_negate(a,b,z) _mm512_mask_sub_epi8(a,_mm512_movepi8_mask(b),z,a)
-void nrLDPC_cnProc_BG1_Z7_13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG1_Z7_R13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m512i zmm0, min, sgn,zeros,maxLLR;
                 zeros  = _mm512_setzero_si512();
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_R13_AVX512.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z80_13_AVX512.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z80_R13_AVX512.c
index 35ec155a7b..cc13115c68 100644
--- 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_R13_AVX512.c
@@ -1,7 +1,7 @@
 #include <stdint.h>
 #include <immintrin.h>
 #define conditional_negate(a,b,z) _mm512_mask_sub_epi8(a,_mm512_movepi8_mask(b),z,a)
-void nrLDPC_cnProc_BG1_Z80_13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG1_Z80_R13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m512i zmm0, min, sgn,zeros,maxLLR;
                 zeros  = _mm512_setzero_si512();
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_R13_AVX512.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z88_13_AVX512.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z88_R13_AVX512.c
index be4ee80c38..9010ccd0b8 100644
--- 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_R13_AVX512.c
@@ -1,7 +1,7 @@
 #include <stdint.h>
 #include <immintrin.h>
 #define conditional_negate(a,b,z) _mm512_mask_sub_epi8(a,_mm512_movepi8_mask(b),z,a)
-void nrLDPC_cnProc_BG1_Z88_13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG1_Z88_R13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m512i zmm0, min, sgn,zeros,maxLLR;
                 zeros  = _mm512_setzero_si512();
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_R13_AVX512.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z8_13_AVX512.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z8_R13_AVX512.c
index 6a05ba3800..097b273aa6 100644
--- 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_R13_AVX512.c
@@ -1,7 +1,7 @@
 #include <stdint.h>
 #include <immintrin.h>
 #define conditional_negate(a,b,z) _mm512_mask_sub_epi8(a,_mm512_movepi8_mask(b),z,a)
-void nrLDPC_cnProc_BG1_Z8_13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG1_Z8_R13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m512i zmm0, min, sgn,zeros,maxLLR;
                 zeros  = _mm512_setzero_si512();
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_R13_AVX512.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z96_13_AVX512.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z96_R13_AVX512.c
index 4bf4f238f7..029b3cd7d5 100644
--- 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_R13_AVX512.c
@@ -1,7 +1,7 @@
 #include <stdint.h>
 #include <immintrin.h>
 #define conditional_negate(a,b,z) _mm512_mask_sub_epi8(a,_mm512_movepi8_mask(b),z,a)
-void nrLDPC_cnProc_BG1_Z96_13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG1_Z96_R13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m512i zmm0, min, sgn,zeros,maxLLR;
                 zeros  = _mm512_setzero_si512();
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_Z9_R13_AVX512.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z10_13_AVX512.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z9_R13_AVX512.c
index a22fe64e88..b8526c1fa0 100644
--- 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_Z9_R13_AVX512.c
@@ -1,7 +1,7 @@
 #include <stdint.h>
 #include <immintrin.h>
 #define conditional_negate(a,b,z) _mm512_mask_sub_epi8(a,_mm512_movepi8_mask(b),z,a)
-void nrLDPC_cnProc_BG1_Z10_13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG1_Z9_R13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m512i zmm0, min, sgn,zeros,maxLLR;
                 zeros  = _mm512_setzero_si512();
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z104_15_AVX512.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z104_R15_AVX512.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z104_15_AVX512.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z104_R15_AVX512.c
index 4d162c2b4a..44c3d05e43 100644
--- a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z104_15_AVX512.c
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z104_R15_AVX512.c
@@ -1,7 +1,7 @@
 #include <stdint.h>
 #include <immintrin.h>
 #define conditional_negate(a,b,z) _mm512_mask_sub_epi8(a,_mm512_movepi8_mask(b),z,a)
-void nrLDPC_cnProc_BG2_Z104_15_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG2_Z104_R15_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m512i zmm0, min, sgn,zeros,maxLLR;
                 zeros  = _mm512_setzero_si512();
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z10_15_AVX512.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z10_R15_AVX512.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z10_15_AVX512.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z10_R15_AVX512.c
index 243b9189ff..13bfc07dc8 100644
--- a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z10_15_AVX512.c
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z10_R15_AVX512.c
@@ -1,7 +1,7 @@
 #include <stdint.h>
 #include <immintrin.h>
 #define conditional_negate(a,b,z) _mm512_mask_sub_epi8(a,_mm512_movepi8_mask(b),z,a)
-void nrLDPC_cnProc_BG2_Z10_15_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG2_Z10_R15_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m512i zmm0, min, sgn,zeros,maxLLR;
                 zeros  = _mm512_setzero_si512();
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z112_15_AVX512.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z112_R15_AVX512.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z112_15_AVX512.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z112_R15_AVX512.c
index abf32524ac..2bfea51617 100644
--- a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z112_15_AVX512.c
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z112_R15_AVX512.c
@@ -1,7 +1,7 @@
 #include <stdint.h>
 #include <immintrin.h>
 #define conditional_negate(a,b,z) _mm512_mask_sub_epi8(a,_mm512_movepi8_mask(b),z,a)
-void nrLDPC_cnProc_BG2_Z112_15_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG2_Z112_R15_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m512i zmm0, min, sgn,zeros,maxLLR;
                 zeros  = _mm512_setzero_si512();
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z11_15_AVX512.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z11_R15_AVX512.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z11_15_AVX512.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z11_R15_AVX512.c
index d92e6844cd..47a9347527 100644
--- a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z11_15_AVX512.c
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z11_R15_AVX512.c
@@ -1,7 +1,7 @@
 #include <stdint.h>
 #include <immintrin.h>
 #define conditional_negate(a,b,z) _mm512_mask_sub_epi8(a,_mm512_movepi8_mask(b),z,a)
-void nrLDPC_cnProc_BG2_Z11_15_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG2_Z11_R15_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m512i zmm0, min, sgn,zeros,maxLLR;
                 zeros  = _mm512_setzero_si512();
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z120_15_AVX512.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z120_R15_AVX512.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z120_15_AVX512.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z120_R15_AVX512.c
index 992269d1ef..8e081006db 100644
--- a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z120_15_AVX512.c
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z120_R15_AVX512.c
@@ -1,7 +1,7 @@
 #include <stdint.h>
 #include <immintrin.h>
 #define conditional_negate(a,b,z) _mm512_mask_sub_epi8(a,_mm512_movepi8_mask(b),z,a)
-void nrLDPC_cnProc_BG2_Z120_15_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG2_Z120_R15_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m512i zmm0, min, sgn,zeros,maxLLR;
                 zeros  = _mm512_setzero_si512();
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z128_15_AVX512.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z128_R15_AVX512.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z128_15_AVX512.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z128_R15_AVX512.c
index 415ff53e5a..212eeeb99a 100644
--- a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z128_15_AVX512.c
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z128_R15_AVX512.c
@@ -1,7 +1,7 @@
 #include <stdint.h>
 #include <immintrin.h>
 #define conditional_negate(a,b,z) _mm512_mask_sub_epi8(a,_mm512_movepi8_mask(b),z,a)
-void nrLDPC_cnProc_BG2_Z128_15_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG2_Z128_R15_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m512i zmm0, min, sgn,zeros,maxLLR;
                 zeros  = _mm512_setzero_si512();
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z12_15_AVX512.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z12_R15_AVX512.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z12_15_AVX512.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z12_R15_AVX512.c
index 4ac92fe5ac..5cc9987065 100644
--- a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z12_15_AVX512.c
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z12_R15_AVX512.c
@@ -1,7 +1,7 @@
 #include <stdint.h>
 #include <immintrin.h>
 #define conditional_negate(a,b,z) _mm512_mask_sub_epi8(a,_mm512_movepi8_mask(b),z,a)
-void nrLDPC_cnProc_BG2_Z12_15_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG2_Z12_R15_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m512i zmm0, min, sgn,zeros,maxLLR;
                 zeros  = _mm512_setzero_si512();
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z14_15_AVX512.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z13_R15_AVX512.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z14_15_AVX512.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z13_R15_AVX512.c
index 96cf1272d7..1a768656bb 100644
--- a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z14_15_AVX512.c
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z13_R15_AVX512.c
@@ -1,7 +1,7 @@
 #include <stdint.h>
 #include <immintrin.h>
 #define conditional_negate(a,b,z) _mm512_mask_sub_epi8(a,_mm512_movepi8_mask(b),z,a)
-void nrLDPC_cnProc_BG2_Z14_15_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG2_Z13_R15_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m512i zmm0, min, sgn,zeros,maxLLR;
                 zeros  = _mm512_setzero_si512();
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z144_15_AVX512.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z144_R15_AVX512.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z144_15_AVX512.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z144_R15_AVX512.c
index 31075c75fe..424d013afa 100644
--- a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z144_15_AVX512.c
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z144_R15_AVX512.c
@@ -1,7 +1,7 @@
 #include <stdint.h>
 #include <immintrin.h>
 #define conditional_negate(a,b,z) _mm512_mask_sub_epi8(a,_mm512_movepi8_mask(b),z,a)
-void nrLDPC_cnProc_BG2_Z144_15_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG2_Z144_R15_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m512i zmm0, min, sgn,zeros,maxLLR;
                 zeros  = _mm512_setzero_si512();
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z13_15_AVX512.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z14_R15_AVX512.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z13_15_AVX512.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z14_R15_AVX512.c
index 9b33ec8dbd..7ac9608117 100644
--- a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z13_15_AVX512.c
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z14_R15_AVX512.c
@@ -1,7 +1,7 @@
 #include <stdint.h>
 #include <immintrin.h>
 #define conditional_negate(a,b,z) _mm512_mask_sub_epi8(a,_mm512_movepi8_mask(b),z,a)
-void nrLDPC_cnProc_BG2_Z13_15_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG2_Z14_R15_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m512i zmm0, min, sgn,zeros,maxLLR;
                 zeros  = _mm512_setzero_si512();
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z15_15_AVX512.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z15_R15_AVX512.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z15_15_AVX512.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z15_R15_AVX512.c
index 1f05cc5a3f..46784bdd5a 100644
--- a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z15_15_AVX512.c
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z15_R15_AVX512.c
@@ -1,7 +1,7 @@
 #include <stdint.h>
 #include <immintrin.h>
 #define conditional_negate(a,b,z) _mm512_mask_sub_epi8(a,_mm512_movepi8_mask(b),z,a)
-void nrLDPC_cnProc_BG2_Z15_15_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG2_Z15_R15_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m512i zmm0, min, sgn,zeros,maxLLR;
                 zeros  = _mm512_setzero_si512();
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z160_15_AVX512.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z160_R15_AVX512.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z160_15_AVX512.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z160_R15_AVX512.c
index ec007c3409..4a456e452d 100644
--- a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z160_15_AVX512.c
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z160_R15_AVX512.c
@@ -1,7 +1,7 @@
 #include <stdint.h>
 #include <immintrin.h>
 #define conditional_negate(a,b,z) _mm512_mask_sub_epi8(a,_mm512_movepi8_mask(b),z,a)
-void nrLDPC_cnProc_BG2_Z160_15_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG2_Z160_R15_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m512i zmm0, min, sgn,zeros,maxLLR;
                 zeros  = _mm512_setzero_si512();
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z16_15_AVX512.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z16_R15_AVX512.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z16_15_AVX512.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z16_R15_AVX512.c
index ac901cecaa..cafbcf0ec3 100644
--- a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z16_15_AVX512.c
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z16_R15_AVX512.c
@@ -1,7 +1,7 @@
 #include <stdint.h>
 #include <immintrin.h>
 #define conditional_negate(a,b,z) _mm512_mask_sub_epi8(a,_mm512_movepi8_mask(b),z,a)
-void nrLDPC_cnProc_BG2_Z16_15_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG2_Z16_R15_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m512i zmm0, min, sgn,zeros,maxLLR;
                 zeros  = _mm512_setzero_si512();
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z176_15_AVX512.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z176_R15_AVX512.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z176_15_AVX512.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z176_R15_AVX512.c
index 7d70b215e1..c7e9c3b9e4 100644
--- a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z176_15_AVX512.c
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z176_R15_AVX512.c
@@ -1,7 +1,7 @@
 #include <stdint.h>
 #include <immintrin.h>
 #define conditional_negate(a,b,z) _mm512_mask_sub_epi8(a,_mm512_movepi8_mask(b),z,a)
-void nrLDPC_cnProc_BG2_Z176_15_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG2_Z176_R15_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m512i zmm0, min, sgn,zeros,maxLLR;
                 zeros  = _mm512_setzero_si512();
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z18_15_AVX512.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z18_R15_AVX512.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z18_15_AVX512.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z18_R15_AVX512.c
index 287ea1c758..7a70ae0856 100644
--- a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z18_15_AVX512.c
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z18_R15_AVX512.c
@@ -1,7 +1,7 @@
 #include <stdint.h>
 #include <immintrin.h>
 #define conditional_negate(a,b,z) _mm512_mask_sub_epi8(a,_mm512_movepi8_mask(b),z,a)
-void nrLDPC_cnProc_BG2_Z18_15_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG2_Z18_R15_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m512i zmm0, min, sgn,zeros,maxLLR;
                 zeros  = _mm512_setzero_si512();
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z192_15_AVX512.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z192_R15_AVX512.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z192_15_AVX512.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z192_R15_AVX512.c
index b6192d38c9..772edee176 100644
--- a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z192_15_AVX512.c
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z192_R15_AVX512.c
@@ -1,7 +1,7 @@
 #include <stdint.h>
 #include <immintrin.h>
 #define conditional_negate(a,b,z) _mm512_mask_sub_epi8(a,_mm512_movepi8_mask(b),z,a)
-void nrLDPC_cnProc_BG2_Z192_15_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG2_Z192_R15_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m512i zmm0, min, sgn,zeros,maxLLR;
                 zeros  = _mm512_setzero_si512();
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z208_15_AVX512.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z208_R15_AVX512.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z208_15_AVX512.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z208_R15_AVX512.c
index 7bd16c5fd8..0d1d45a2da 100644
--- a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z208_15_AVX512.c
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z208_R15_AVX512.c
@@ -1,7 +1,7 @@
 #include <stdint.h>
 #include <immintrin.h>
 #define conditional_negate(a,b,z) _mm512_mask_sub_epi8(a,_mm512_movepi8_mask(b),z,a)
-void nrLDPC_cnProc_BG2_Z208_15_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG2_Z208_R15_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m512i zmm0, min, sgn,zeros,maxLLR;
                 zeros  = _mm512_setzero_si512();
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z20_15_AVX512.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z20_R15_AVX512.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z20_15_AVX512.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z20_R15_AVX512.c
index c0e94bcadc..808d1d557e 100644
--- a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z20_15_AVX512.c
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z20_R15_AVX512.c
@@ -1,7 +1,7 @@
 #include <stdint.h>
 #include <immintrin.h>
 #define conditional_negate(a,b,z) _mm512_mask_sub_epi8(a,_mm512_movepi8_mask(b),z,a)
-void nrLDPC_cnProc_BG2_Z20_15_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG2_Z20_R15_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m512i zmm0, min, sgn,zeros,maxLLR;
                 zeros  = _mm512_setzero_si512();
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z224_15_AVX512.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z224_R15_AVX512.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z224_15_AVX512.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z224_R15_AVX512.c
index 3a4e8f12ec..5040a8055c 100644
--- a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z224_15_AVX512.c
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z224_R15_AVX512.c
@@ -1,7 +1,7 @@
 #include <stdint.h>
 #include <immintrin.h>
 #define conditional_negate(a,b,z) _mm512_mask_sub_epi8(a,_mm512_movepi8_mask(b),z,a)
-void nrLDPC_cnProc_BG2_Z224_15_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG2_Z224_R15_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m512i zmm0, min, sgn,zeros,maxLLR;
                 zeros  = _mm512_setzero_si512();
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z22_15_AVX512.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z22_R15_AVX512.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z22_15_AVX512.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z22_R15_AVX512.c
index 6a4f14e60b..d6bc032b37 100644
--- a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z22_15_AVX512.c
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z22_R15_AVX512.c
@@ -1,7 +1,7 @@
 #include <stdint.h>
 #include <immintrin.h>
 #define conditional_negate(a,b,z) _mm512_mask_sub_epi8(a,_mm512_movepi8_mask(b),z,a)
-void nrLDPC_cnProc_BG2_Z22_15_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG2_Z22_R15_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m512i zmm0, min, sgn,zeros,maxLLR;
                 zeros  = _mm512_setzero_si512();
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z240_15_AVX512.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z240_R15_AVX512.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z240_15_AVX512.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z240_R15_AVX512.c
index bed7d24a36..b6aa90ffaa 100644
--- a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z240_15_AVX512.c
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z240_R15_AVX512.c
@@ -1,7 +1,7 @@
 #include <stdint.h>
 #include <immintrin.h>
 #define conditional_negate(a,b,z) _mm512_mask_sub_epi8(a,_mm512_movepi8_mask(b),z,a)
-void nrLDPC_cnProc_BG2_Z240_15_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG2_Z240_R15_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m512i zmm0, min, sgn,zeros,maxLLR;
                 zeros  = _mm512_setzero_si512();
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z24_15_AVX512.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z24_R15_AVX512.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z24_15_AVX512.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z24_R15_AVX512.c
index bfaf3291a5..200e410ddd 100644
--- a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z24_15_AVX512.c
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z24_R15_AVX512.c
@@ -1,7 +1,7 @@
 #include <stdint.h>
 #include <immintrin.h>
 #define conditional_negate(a,b,z) _mm512_mask_sub_epi8(a,_mm512_movepi8_mask(b),z,a)
-void nrLDPC_cnProc_BG2_Z24_15_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG2_Z24_R15_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m512i zmm0, min, sgn,zeros,maxLLR;
                 zeros  = _mm512_setzero_si512();
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z256_15_AVX512.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z256_R15_AVX512.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z256_15_AVX512.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z256_R15_AVX512.c
index 013389c562..baba4c6496 100644
--- a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z256_15_AVX512.c
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z256_R15_AVX512.c
@@ -1,7 +1,7 @@
 #include <stdint.h>
 #include <immintrin.h>
 #define conditional_negate(a,b,z) _mm512_mask_sub_epi8(a,_mm512_movepi8_mask(b),z,a)
-void nrLDPC_cnProc_BG2_Z256_15_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG2_Z256_R15_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m512i zmm0, min, sgn,zeros,maxLLR;
                 zeros  = _mm512_setzero_si512();
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z26_15_AVX512.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z26_R15_AVX512.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z26_15_AVX512.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z26_R15_AVX512.c
index f375a17eda..3f7f3e3ca1 100644
--- a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z26_15_AVX512.c
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z26_R15_AVX512.c
@@ -1,7 +1,7 @@
 #include <stdint.h>
 #include <immintrin.h>
 #define conditional_negate(a,b,z) _mm512_mask_sub_epi8(a,_mm512_movepi8_mask(b),z,a)
-void nrLDPC_cnProc_BG2_Z26_15_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG2_Z26_R15_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m512i zmm0, min, sgn,zeros,maxLLR;
                 zeros  = _mm512_setzero_si512();
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z288_15_AVX512.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z288_R15_AVX512.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z288_15_AVX512.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z288_R15_AVX512.c
index a660eef000..be696e744c 100644
--- a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z288_15_AVX512.c
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z288_R15_AVX512.c
@@ -1,7 +1,7 @@
 #include <stdint.h>
 #include <immintrin.h>
 #define conditional_negate(a,b,z) _mm512_mask_sub_epi8(a,_mm512_movepi8_mask(b),z,a)
-void nrLDPC_cnProc_BG2_Z288_15_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG2_Z288_R15_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m512i zmm0, min, sgn,zeros,maxLLR;
                 zeros  = _mm512_setzero_si512();
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z28_15_AVX512.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z28_R15_AVX512.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z28_15_AVX512.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z28_R15_AVX512.c
index 580ce518a0..fe487719cf 100644
--- a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z28_15_AVX512.c
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z28_R15_AVX512.c
@@ -1,7 +1,7 @@
 #include <stdint.h>
 #include <immintrin.h>
 #define conditional_negate(a,b,z) _mm512_mask_sub_epi8(a,_mm512_movepi8_mask(b),z,a)
-void nrLDPC_cnProc_BG2_Z28_15_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG2_Z28_R15_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m512i zmm0, min, sgn,zeros,maxLLR;
                 zeros  = _mm512_setzero_si512();
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z2_15_AVX512.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z2_R15_AVX512.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z2_15_AVX512.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z2_R15_AVX512.c
index 51cb67c986..b94d3783d4 100644
--- a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z2_15_AVX512.c
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z2_R15_AVX512.c
@@ -1,7 +1,7 @@
 #include <stdint.h>
 #include <immintrin.h>
 #define conditional_negate(a,b,z) _mm512_mask_sub_epi8(a,_mm512_movepi8_mask(b),z,a)
-void nrLDPC_cnProc_BG2_Z2_15_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG2_Z2_R15_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m512i zmm0, min, sgn,zeros,maxLLR;
                 zeros  = _mm512_setzero_si512();
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z30_15_AVX512.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z30_R15_AVX512.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z30_15_AVX512.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z30_R15_AVX512.c
index a50a01b734..aae2a813c7 100644
--- a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z30_15_AVX512.c
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z30_R15_AVX512.c
@@ -1,7 +1,7 @@
 #include <stdint.h>
 #include <immintrin.h>
 #define conditional_negate(a,b,z) _mm512_mask_sub_epi8(a,_mm512_movepi8_mask(b),z,a)
-void nrLDPC_cnProc_BG2_Z30_15_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG2_Z30_R15_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m512i zmm0, min, sgn,zeros,maxLLR;
                 zeros  = _mm512_setzero_si512();
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z320_15_AVX512.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z320_R15_AVX512.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z320_15_AVX512.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z320_R15_AVX512.c
index 88d88a389a..2ba9f47ab9 100644
--- a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z320_15_AVX512.c
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z320_R15_AVX512.c
@@ -1,7 +1,7 @@
 #include <stdint.h>
 #include <immintrin.h>
 #define conditional_negate(a,b,z) _mm512_mask_sub_epi8(a,_mm512_movepi8_mask(b),z,a)
-void nrLDPC_cnProc_BG2_Z320_15_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG2_Z320_R15_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m512i zmm0, min, sgn,zeros,maxLLR;
                 zeros  = _mm512_setzero_si512();
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z32_15_AVX512.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z32_R15_AVX512.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z32_15_AVX512.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z32_R15_AVX512.c
index b8687235ad..ecc660ddf6 100644
--- a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z32_15_AVX512.c
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z32_R15_AVX512.c
@@ -1,7 +1,7 @@
 #include <stdint.h>
 #include <immintrin.h>
 #define conditional_negate(a,b,z) _mm512_mask_sub_epi8(a,_mm512_movepi8_mask(b),z,a)
-void nrLDPC_cnProc_BG2_Z32_15_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG2_Z32_R15_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m512i zmm0, min, sgn,zeros,maxLLR;
                 zeros  = _mm512_setzero_si512();
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z352_15_AVX512.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z352_R15_AVX512.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z352_15_AVX512.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z352_R15_AVX512.c
index 29a64dc1cd..7cb4a18389 100644
--- a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z352_15_AVX512.c
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z352_R15_AVX512.c
@@ -1,7 +1,7 @@
 #include <stdint.h>
 #include <immintrin.h>
 #define conditional_negate(a,b,z) _mm512_mask_sub_epi8(a,_mm512_movepi8_mask(b),z,a)
-void nrLDPC_cnProc_BG2_Z352_15_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG2_Z352_R15_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m512i zmm0, min, sgn,zeros,maxLLR;
                 zeros  = _mm512_setzero_si512();
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z36_15_AVX512.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z36_R15_AVX512.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z36_15_AVX512.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z36_R15_AVX512.c
index d8b7843ca1..33ab4c8a85 100644
--- a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z36_15_AVX512.c
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z36_R15_AVX512.c
@@ -1,7 +1,7 @@
 #include <stdint.h>
 #include <immintrin.h>
 #define conditional_negate(a,b,z) _mm512_mask_sub_epi8(a,_mm512_movepi8_mask(b),z,a)
-void nrLDPC_cnProc_BG2_Z36_15_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG2_Z36_R15_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m512i zmm0, min, sgn,zeros,maxLLR;
                 zeros  = _mm512_setzero_si512();
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z384_15_AVX512.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z384_R15_AVX512.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z384_15_AVX512.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z384_R15_AVX512.c
index baf037fe0b..38a3c6deec 100644
--- a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z384_15_AVX512.c
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z384_R15_AVX512.c
@@ -1,7 +1,7 @@
 #include <stdint.h>
 #include <immintrin.h>
 #define conditional_negate(a,b,z) _mm512_mask_sub_epi8(a,_mm512_movepi8_mask(b),z,a)
-void nrLDPC_cnProc_BG2_Z384_15_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG2_Z384_R15_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m512i zmm0, min, sgn,zeros,maxLLR;
                 zeros  = _mm512_setzero_si512();
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z3_15_AVX512.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z3_R15_AVX512.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z3_15_AVX512.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z3_R15_AVX512.c
index 95b960548e..e24d00d8f7 100644
--- a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z3_15_AVX512.c
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z3_R15_AVX512.c
@@ -1,7 +1,7 @@
 #include <stdint.h>
 #include <immintrin.h>
 #define conditional_negate(a,b,z) _mm512_mask_sub_epi8(a,_mm512_movepi8_mask(b),z,a)
-void nrLDPC_cnProc_BG2_Z3_15_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG2_Z3_R15_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m512i zmm0, min, sgn,zeros,maxLLR;
                 zeros  = _mm512_setzero_si512();
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z40_15_AVX512.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z40_R15_AVX512.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z40_15_AVX512.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z40_R15_AVX512.c
index 10a8b929ed..9603e1669a 100644
--- a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z40_15_AVX512.c
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z40_R15_AVX512.c
@@ -1,7 +1,7 @@
 #include <stdint.h>
 #include <immintrin.h>
 #define conditional_negate(a,b,z) _mm512_mask_sub_epi8(a,_mm512_movepi8_mask(b),z,a)
-void nrLDPC_cnProc_BG2_Z40_15_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG2_Z40_R15_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m512i zmm0, min, sgn,zeros,maxLLR;
                 zeros  = _mm512_setzero_si512();
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z44_15_AVX512.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z44_R15_AVX512.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z44_15_AVX512.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z44_R15_AVX512.c
index 466fdd86d3..f930d6ae14 100644
--- a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z44_15_AVX512.c
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z44_R15_AVX512.c
@@ -1,7 +1,7 @@
 #include <stdint.h>
 #include <immintrin.h>
 #define conditional_negate(a,b,z) _mm512_mask_sub_epi8(a,_mm512_movepi8_mask(b),z,a)
-void nrLDPC_cnProc_BG2_Z44_15_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG2_Z44_R15_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m512i zmm0, min, sgn,zeros,maxLLR;
                 zeros  = _mm512_setzero_si512();
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z48_15_AVX512.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z48_R15_AVX512.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z48_15_AVX512.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z48_R15_AVX512.c
index 084d8ba087..541fd39183 100644
--- a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z48_15_AVX512.c
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z48_R15_AVX512.c
@@ -1,7 +1,7 @@
 #include <stdint.h>
 #include <immintrin.h>
 #define conditional_negate(a,b,z) _mm512_mask_sub_epi8(a,_mm512_movepi8_mask(b),z,a)
-void nrLDPC_cnProc_BG2_Z48_15_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG2_Z48_R15_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m512i zmm0, min, sgn,zeros,maxLLR;
                 zeros  = _mm512_setzero_si512();
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z6_15_AVX512.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z4_R15_AVX512.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z6_15_AVX512.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z4_R15_AVX512.c
index a7156664d9..1244fbb05c 100644
--- a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z6_15_AVX512.c
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z4_R15_AVX512.c
@@ -1,7 +1,7 @@
 #include <stdint.h>
 #include <immintrin.h>
 #define conditional_negate(a,b,z) _mm512_mask_sub_epi8(a,_mm512_movepi8_mask(b),z,a)
-void nrLDPC_cnProc_BG2_Z6_15_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG2_Z4_R15_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m512i zmm0, min, sgn,zeros,maxLLR;
                 zeros  = _mm512_setzero_si512();
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z52_15_AVX512.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z52_R15_AVX512.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z52_15_AVX512.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z52_R15_AVX512.c
index ea2106788e..d974028049 100644
--- a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z52_15_AVX512.c
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z52_R15_AVX512.c
@@ -1,7 +1,7 @@
 #include <stdint.h>
 #include <immintrin.h>
 #define conditional_negate(a,b,z) _mm512_mask_sub_epi8(a,_mm512_movepi8_mask(b),z,a)
-void nrLDPC_cnProc_BG2_Z52_15_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG2_Z52_R15_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m512i zmm0, min, sgn,zeros,maxLLR;
                 zeros  = _mm512_setzero_si512();
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z56_15_AVX512.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z56_R15_AVX512.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z56_15_AVX512.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z56_R15_AVX512.c
index 807e1067e5..fe905cfdc4 100644
--- a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z56_15_AVX512.c
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z56_R15_AVX512.c
@@ -1,7 +1,7 @@
 #include <stdint.h>
 #include <immintrin.h>
 #define conditional_negate(a,b,z) _mm512_mask_sub_epi8(a,_mm512_movepi8_mask(b),z,a)
-void nrLDPC_cnProc_BG2_Z56_15_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG2_Z56_R15_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m512i zmm0, min, sgn,zeros,maxLLR;
                 zeros  = _mm512_setzero_si512();
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z4_15_AVX512.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z5_R15_AVX512.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z4_15_AVX512.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z5_R15_AVX512.c
index 0430c08f50..627309b2ba 100644
--- a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z4_15_AVX512.c
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z5_R15_AVX512.c
@@ -1,7 +1,7 @@
 #include <stdint.h>
 #include <immintrin.h>
 #define conditional_negate(a,b,z) _mm512_mask_sub_epi8(a,_mm512_movepi8_mask(b),z,a)
-void nrLDPC_cnProc_BG2_Z4_15_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG2_Z5_R15_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m512i zmm0, min, sgn,zeros,maxLLR;
                 zeros  = _mm512_setzero_si512();
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z60_15_AVX512.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z60_R15_AVX512.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z60_15_AVX512.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z60_R15_AVX512.c
index c0cc4cd03d..332175bebe 100644
--- a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z60_15_AVX512.c
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z60_R15_AVX512.c
@@ -1,7 +1,7 @@
 #include <stdint.h>
 #include <immintrin.h>
 #define conditional_negate(a,b,z) _mm512_mask_sub_epi8(a,_mm512_movepi8_mask(b),z,a)
-void nrLDPC_cnProc_BG2_Z60_15_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG2_Z60_R15_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m512i zmm0, min, sgn,zeros,maxLLR;
                 zeros  = _mm512_setzero_si512();
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z64_15_AVX512.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z64_R15_AVX512.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z64_15_AVX512.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z64_R15_AVX512.c
index 0007ff6f4f..d44251a81e 100644
--- a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z64_15_AVX512.c
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z64_R15_AVX512.c
@@ -1,7 +1,7 @@
 #include <stdint.h>
 #include <immintrin.h>
 #define conditional_negate(a,b,z) _mm512_mask_sub_epi8(a,_mm512_movepi8_mask(b),z,a)
-void nrLDPC_cnProc_BG2_Z64_15_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG2_Z64_R15_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m512i zmm0, min, sgn,zeros,maxLLR;
                 zeros  = _mm512_setzero_si512();
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z5_15_AVX512.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z6_R15_AVX512.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z5_15_AVX512.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z6_R15_AVX512.c
index 8d5af4ee74..429dedff76 100644
--- a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z5_15_AVX512.c
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z6_R15_AVX512.c
@@ -1,7 +1,7 @@
 #include <stdint.h>
 #include <immintrin.h>
 #define conditional_negate(a,b,z) _mm512_mask_sub_epi8(a,_mm512_movepi8_mask(b),z,a)
-void nrLDPC_cnProc_BG2_Z5_15_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG2_Z6_R15_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m512i zmm0, min, sgn,zeros,maxLLR;
                 zeros  = _mm512_setzero_si512();
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z72_15_AVX512.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z72_R15_AVX512.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z72_15_AVX512.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z72_R15_AVX512.c
index 87b1e951db..af7bd6082d 100644
--- a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z72_15_AVX512.c
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z72_R15_AVX512.c
@@ -1,7 +1,7 @@
 #include <stdint.h>
 #include <immintrin.h>
 #define conditional_negate(a,b,z) _mm512_mask_sub_epi8(a,_mm512_movepi8_mask(b),z,a)
-void nrLDPC_cnProc_BG2_Z72_15_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG2_Z72_R15_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m512i zmm0, min, sgn,zeros,maxLLR;
                 zeros  = _mm512_setzero_si512();
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z7_15_AVX512.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z7_R15_AVX512.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z7_15_AVX512.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z7_R15_AVX512.c
index 6ea5bc85f9..9e060eef9b 100644
--- a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z7_15_AVX512.c
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z7_R15_AVX512.c
@@ -1,7 +1,7 @@
 #include <stdint.h>
 #include <immintrin.h>
 #define conditional_negate(a,b,z) _mm512_mask_sub_epi8(a,_mm512_movepi8_mask(b),z,a)
-void nrLDPC_cnProc_BG2_Z7_15_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG2_Z7_R15_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m512i zmm0, min, sgn,zeros,maxLLR;
                 zeros  = _mm512_setzero_si512();
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z80_15_AVX512.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z80_R15_AVX512.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z80_15_AVX512.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z80_R15_AVX512.c
index 9daeb6a287..9191e45570 100644
--- a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z80_15_AVX512.c
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z80_R15_AVX512.c
@@ -1,7 +1,7 @@
 #include <stdint.h>
 #include <immintrin.h>
 #define conditional_negate(a,b,z) _mm512_mask_sub_epi8(a,_mm512_movepi8_mask(b),z,a)
-void nrLDPC_cnProc_BG2_Z80_15_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG2_Z80_R15_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m512i zmm0, min, sgn,zeros,maxLLR;
                 zeros  = _mm512_setzero_si512();
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z88_15_AVX512.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z88_R15_AVX512.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z88_15_AVX512.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z88_R15_AVX512.c
index b58b3c72ce..c8cd9df6af 100644
--- a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z88_15_AVX512.c
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z88_R15_AVX512.c
@@ -1,7 +1,7 @@
 #include <stdint.h>
 #include <immintrin.h>
 #define conditional_negate(a,b,z) _mm512_mask_sub_epi8(a,_mm512_movepi8_mask(b),z,a)
-void nrLDPC_cnProc_BG2_Z88_15_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG2_Z88_R15_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m512i zmm0, min, sgn,zeros,maxLLR;
                 zeros  = _mm512_setzero_si512();
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z8_15_AVX512.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z8_R15_AVX512.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z8_15_AVX512.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z8_R15_AVX512.c
index 15e990a7d2..c8a4c790d1 100644
--- a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z8_15_AVX512.c
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z8_R15_AVX512.c
@@ -1,7 +1,7 @@
 #include <stdint.h>
 #include <immintrin.h>
 #define conditional_negate(a,b,z) _mm512_mask_sub_epi8(a,_mm512_movepi8_mask(b),z,a)
-void nrLDPC_cnProc_BG2_Z8_15_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG2_Z8_R15_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m512i zmm0, min, sgn,zeros,maxLLR;
                 zeros  = _mm512_setzero_si512();
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z96_15_AVX512.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z96_R15_AVX512.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z96_15_AVX512.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z96_R15_AVX512.c
index 4447d802b8..1a2b478180 100644
--- a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z96_15_AVX512.c
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z96_R15_AVX512.c
@@ -1,7 +1,7 @@
 #include <stdint.h>
 #include <immintrin.h>
 #define conditional_negate(a,b,z) _mm512_mask_sub_epi8(a,_mm512_movepi8_mask(b),z,a)
-void nrLDPC_cnProc_BG2_Z96_15_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG2_Z96_R15_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m512i zmm0, min, sgn,zeros,maxLLR;
                 zeros  = _mm512_setzero_si512();
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z9_15_AVX512.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z9_R15_AVX512.c
similarity index 99%
rename from openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z9_15_AVX512.c
rename to openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z9_R15_AVX512.c
index 1b5492e4a3..b3e2eb87ec 100644
--- a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z9_15_AVX512.c
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG2_Z9_R15_AVX512.c
@@ -1,7 +1,7 @@
 #include <stdint.h>
 #include <immintrin.h>
 #define conditional_negate(a,b,z) _mm512_mask_sub_epi8(a,_mm512_movepi8_mask(b),z,a)
-void nrLDPC_cnProc_BG2_Z9_15_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
+void nrLDPC_cnProc_BG2_Z9_R15_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) {
 //Process group with 3 BNs
                 __m512i zmm0, min, sgn,zeros,maxLLR;
                 zeros  = _mm512_setzero_si512();